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 #include "completer.h"
58 #include "filestuff.h"
60 /* readline include files */
61 #include "readline/readline.h"
62 #include "readline/history.h"
64 /* readline defines this. */
75 /* Maximum length of an agent aexpression.
76 This accounts for the fact that packets are limited to 400 bytes
77 (which includes everything -- including the checksum), and assumes
78 the worst case of maximum length for each of the pieces of a
81 NOTE: expressions get mem2hex'ed otherwise this would be twice as
82 large. (400 - 31)/2 == 184 */
83 #define MAX_AGENT_EXPR_LEN 184
85 /* A hook used to notify the UI of tracepoint operations. */
87 void (*deprecated_trace_find_hook) (char *arg, int from_tty);
88 void (*deprecated_trace_start_stop_hook) (int start, int from_tty);
90 extern void (*deprecated_readline_begin_hook) (char *, ...);
91 extern char *(*deprecated_readline_hook) (char *);
92 extern void (*deprecated_readline_end_hook) (void);
97 This module defines the following debugger commands:
98 trace : set a tracepoint on a function, line, or address.
99 info trace : list all debugger-defined tracepoints.
100 delete trace : delete one or more tracepoints.
101 enable trace : enable one or more tracepoints.
102 disable trace : disable one or more tracepoints.
103 actions : specify actions to be taken at a tracepoint.
104 passcount : specify a pass count for a tracepoint.
105 tstart : start a trace experiment.
106 tstop : stop a trace experiment.
107 tstatus : query the status of a trace experiment.
108 tfind : find a trace frame in the trace buffer.
109 tdump : print everything collected at the current tracepoint.
110 save-tracepoints : write tracepoint setup into a file.
112 This module defines the following user-visible debugger variables:
113 $trace_frame : sequence number of trace frame currently being debugged.
114 $trace_line : source line of trace frame currently being debugged.
115 $trace_file : source file of trace frame currently being debugged.
116 $tracepoint : tracepoint number of trace frame currently being debugged.
120 /* ======= Important global variables: ======= */
122 /* The list of all trace state variables. We don't retain pointers to
123 any of these for any reason - API is by name or number only - so it
124 works to have a vector of objects. */
126 typedef struct trace_state_variable tsv_s;
129 static VEC(tsv_s) *tvariables;
131 /* The next integer to assign to a variable. */
133 static int next_tsv_number = 1;
135 /* Number of last traceframe collected. */
136 static int traceframe_number;
138 /* Tracepoint for last traceframe collected. */
139 static int tracepoint_number;
141 /* Symbol for function for last traceframe collected. */
142 static struct symbol *traceframe_fun;
144 /* Symtab and line for last traceframe collected. */
145 static struct symtab_and_line traceframe_sal;
147 /* The traceframe info of the current traceframe. NULL if we haven't
148 yet attempted to fetch it, or if the target does not support
149 fetching this object, or if we're not inspecting a traceframe
151 static struct traceframe_info *traceframe_info;
153 /* Tracing command lists. */
154 static struct cmd_list_element *tfindlist;
156 /* List of expressions to collect by default at each tracepoint hit. */
157 char *default_collect = "";
159 static int disconnected_tracing;
161 /* This variable controls whether we ask the target for a linear or
162 circular trace buffer. */
164 static int circular_trace_buffer;
166 /* This variable is the requested trace buffer size, or -1 to indicate
167 that we don't care and leave it up to the target to set a size. */
169 static int trace_buffer_size = -1;
171 /* Textual notes applying to the current and/or future trace runs. */
173 char *trace_user = NULL;
175 /* Textual notes applying to the current and/or future trace runs. */
177 char *trace_notes = NULL;
179 /* Textual notes applying to the stopping of a trace. */
181 char *trace_stop_notes = NULL;
183 /* ======= Important command functions: ======= */
184 static void trace_actions_command (char *, int);
185 static void trace_start_command (char *, int);
186 static void trace_stop_command (char *, int);
187 static void trace_status_command (char *, int);
188 static void trace_find_command (char *, int);
189 static void trace_find_pc_command (char *, int);
190 static void trace_find_tracepoint_command (char *, int);
191 static void trace_find_line_command (char *, int);
192 static void trace_find_range_command (char *, int);
193 static void trace_find_outside_command (char *, int);
194 static void trace_dump_command (char *, int);
196 /* support routines */
198 struct collection_list;
199 static void add_aexpr (struct collection_list *, struct agent_expr *);
200 static char *mem2hex (gdb_byte *, char *, int);
201 static void add_register (struct collection_list *collection,
204 static void free_uploaded_tps (struct uploaded_tp **utpp);
205 static void free_uploaded_tsvs (struct uploaded_tsv **utsvp);
207 static struct command_line *
208 all_tracepoint_actions_and_cleanup (struct breakpoint *t);
210 extern void _initialize_tracepoint (void);
212 static struct trace_status trace_status;
214 char *stop_reason_names[] = {
224 struct trace_status *
225 current_trace_status (void)
227 return &trace_status;
233 free_traceframe_info (struct traceframe_info *info)
237 VEC_free (mem_range_s, info->memory);
243 /* Free and clear the traceframe info cache of the current
247 clear_traceframe_info (void)
249 free_traceframe_info (traceframe_info);
250 traceframe_info = NULL;
253 /* Set traceframe number to NUM. */
255 set_traceframe_num (int num)
257 traceframe_number = num;
258 set_internalvar_integer (lookup_internalvar ("trace_frame"), num);
261 /* Set tracepoint number to NUM. */
263 set_tracepoint_num (int num)
265 tracepoint_number = num;
266 set_internalvar_integer (lookup_internalvar ("tracepoint"), num);
269 /* Set externally visible debug variables for querying/printing
270 the traceframe context (line, function, file). */
273 set_traceframe_context (struct frame_info *trace_frame)
277 /* Save as globals for internal use. */
278 if (trace_frame != NULL
279 && get_frame_pc_if_available (trace_frame, &trace_pc))
281 traceframe_sal = find_pc_line (trace_pc, 0);
282 traceframe_fun = find_pc_function (trace_pc);
284 /* Save linenumber as "$trace_line", a debugger variable visible to
286 set_internalvar_integer (lookup_internalvar ("trace_line"),
287 traceframe_sal.line);
291 init_sal (&traceframe_sal);
292 traceframe_fun = NULL;
293 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
296 /* Save func name as "$trace_func", a debugger variable visible to
298 if (traceframe_fun == NULL
299 || SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL)
300 clear_internalvar (lookup_internalvar ("trace_func"));
302 set_internalvar_string (lookup_internalvar ("trace_func"),
303 SYMBOL_LINKAGE_NAME (traceframe_fun));
305 /* Save file name as "$trace_file", a debugger variable visible to
307 if (traceframe_sal.symtab == NULL)
308 clear_internalvar (lookup_internalvar ("trace_file"));
310 set_internalvar_string (lookup_internalvar ("trace_file"),
311 symtab_to_filename_for_display (traceframe_sal.symtab));
314 /* Create a new trace state variable with the given name. */
316 struct trace_state_variable *
317 create_trace_state_variable (const char *name)
319 struct trace_state_variable tsv;
321 memset (&tsv, 0, sizeof (tsv));
322 tsv.name = xstrdup (name);
323 tsv.number = next_tsv_number++;
324 return VEC_safe_push (tsv_s, tvariables, &tsv);
327 /* Look for a trace state variable of the given name. */
329 struct trace_state_variable *
330 find_trace_state_variable (const char *name)
332 struct trace_state_variable *tsv;
335 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
336 if (strcmp (name, tsv->name) == 0)
343 delete_trace_state_variable (const char *name)
345 struct trace_state_variable *tsv;
348 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
349 if (strcmp (name, tsv->name) == 0)
351 observer_notify_tsv_deleted (tsv);
353 xfree ((void *)tsv->name);
354 VEC_unordered_remove (tsv_s, tvariables, ix);
359 warning (_("No trace variable named \"$%s\", not deleting"), name);
362 /* Throws an error if NAME is not valid syntax for a trace state
366 validate_trace_state_variable_name (const char *name)
371 error (_("Must supply a non-empty variable name"));
373 /* All digits in the name is reserved for value history
375 for (p = name; isdigit (*p); p++)
378 error (_("$%s is not a valid trace state variable name"), name);
380 for (p = name; isalnum (*p) || *p == '_'; p++)
383 error (_("$%s is not a valid trace state variable name"), name);
386 /* The 'tvariable' command collects a name and optional expression to
387 evaluate into an initial value. */
390 trace_variable_command (char *args, int from_tty)
392 struct cleanup *old_chain;
394 struct trace_state_variable *tsv;
398 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
400 /* Only allow two syntaxes; "$name" and "$name=value". */
401 p = skip_spaces (args);
404 error (_("Name of trace variable should start with '$'"));
407 while (isalnum (*p) || *p == '_')
409 name = savestring (name, p - name);
410 old_chain = make_cleanup (xfree, name);
413 if (*p != '=' && *p != '\0')
414 error (_("Syntax must be $NAME [ = EXPR ]"));
416 validate_trace_state_variable_name (name);
419 initval = value_as_long (parse_and_eval (++p));
421 /* If the variable already exists, just change its initial value. */
422 tsv = find_trace_state_variable (name);
425 if (tsv->initial_value != initval)
427 tsv->initial_value = initval;
428 observer_notify_tsv_modified (tsv);
430 printf_filtered (_("Trace state variable $%s "
431 "now has initial value %s.\n"),
432 tsv->name, plongest (tsv->initial_value));
433 do_cleanups (old_chain);
437 /* Create a new variable. */
438 tsv = create_trace_state_variable (name);
439 tsv->initial_value = initval;
441 observer_notify_tsv_created (tsv);
443 printf_filtered (_("Trace state variable $%s "
444 "created, with initial value %s.\n"),
445 tsv->name, plongest (tsv->initial_value));
447 do_cleanups (old_chain);
451 delete_trace_variable_command (char *args, int from_tty)
455 struct cleanup *back_to;
459 if (query (_("Delete all trace state variables? ")))
460 VEC_free (tsv_s, tvariables);
462 observer_notify_tsv_deleted (NULL);
466 argv = gdb_buildargv (args);
467 back_to = make_cleanup_freeargv (argv);
469 for (ix = 0; argv[ix] != NULL; ix++)
471 if (*argv[ix] == '$')
472 delete_trace_state_variable (argv[ix] + 1);
474 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv[ix]);
477 do_cleanups (back_to);
483 tvariables_info_1 (void)
485 struct trace_state_variable *tsv;
488 struct cleanup *back_to;
489 struct ui_out *uiout = current_uiout;
491 if (VEC_length (tsv_s, tvariables) == 0 && !ui_out_is_mi_like_p (uiout))
493 printf_filtered (_("No trace state variables.\n"));
497 /* Try to acquire values from the target. */
498 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix, ++count)
499 tsv->value_known = target_get_trace_state_variable_value (tsv->number,
502 back_to = make_cleanup_ui_out_table_begin_end (uiout, 3,
503 count, "trace-variables");
504 ui_out_table_header (uiout, 15, ui_left, "name", "Name");
505 ui_out_table_header (uiout, 11, ui_left, "initial", "Initial");
506 ui_out_table_header (uiout, 11, ui_left, "current", "Current");
508 ui_out_table_body (uiout);
510 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
512 struct cleanup *back_to2;
516 back_to2 = make_cleanup_ui_out_tuple_begin_end (uiout, "variable");
518 name = concat ("$", tsv->name, (char *) NULL);
519 make_cleanup (xfree, name);
520 ui_out_field_string (uiout, "name", name);
521 ui_out_field_string (uiout, "initial", plongest (tsv->initial_value));
523 if (tsv->value_known)
524 c = plongest (tsv->value);
525 else if (ui_out_is_mi_like_p (uiout))
526 /* For MI, we prefer not to use magic string constants, but rather
527 omit the field completely. The difference between unknown and
528 undefined does not seem important enough to represent. */
530 else if (current_trace_status ()->running || traceframe_number >= 0)
531 /* The value is/was defined, but we don't have it. */
534 /* It is not meaningful to ask about the value. */
537 ui_out_field_string (uiout, "current", c);
538 ui_out_text (uiout, "\n");
540 do_cleanups (back_to2);
543 do_cleanups (back_to);
546 /* List all the trace state variables. */
549 tvariables_info (char *args, int from_tty)
551 tvariables_info_1 ();
554 /* Stash definitions of tsvs into the given file. */
557 save_trace_state_variables (struct ui_file *fp)
559 struct trace_state_variable *tsv;
562 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
564 fprintf_unfiltered (fp, "tvariable $%s", tsv->name);
565 if (tsv->initial_value)
566 fprintf_unfiltered (fp, " = %s", plongest (tsv->initial_value));
567 fprintf_unfiltered (fp, "\n");
571 /* ACTIONS functions: */
573 /* The three functions:
574 collect_pseudocommand,
575 while_stepping_pseudocommand, and
576 end_actions_pseudocommand
577 are placeholders for "commands" that are actually ONLY to be used
578 within a tracepoint action list. If the actual function is ever called,
579 it means that somebody issued the "command" at the top level,
580 which is always an error. */
583 end_actions_pseudocommand (char *args, int from_tty)
585 error (_("This command cannot be used at the top level."));
589 while_stepping_pseudocommand (char *args, int from_tty)
591 error (_("This command can only be used in a tracepoint actions list."));
595 collect_pseudocommand (char *args, int from_tty)
597 error (_("This command can only be used in a tracepoint actions list."));
601 teval_pseudocommand (char *args, int from_tty)
603 error (_("This command can only be used in a tracepoint actions list."));
606 /* Parse any collection options, such as /s for strings. */
609 decode_agent_options (const char *exp, int *trace_string)
611 struct value_print_options opts;
618 /* Call this to borrow the print elements default for collection
620 get_user_print_options (&opts);
625 if (target_supports_string_tracing ())
627 /* Allow an optional decimal number giving an explicit maximum
628 string length, defaulting it to the "print elements" value;
629 so "collect/s80 mystr" gets at most 80 bytes of string. */
630 *trace_string = opts.print_max;
632 if (*exp >= '0' && *exp <= '9')
633 *trace_string = atoi (exp);
634 while (*exp >= '0' && *exp <= '9')
638 error (_("Target does not support \"/s\" option for string tracing."));
641 error (_("Undefined collection format \"%c\"."), *exp);
643 exp = skip_spaces_const (exp);
648 /* Enter a list of actions for a tracepoint. */
650 trace_actions_command (char *args, int from_tty)
652 struct tracepoint *t;
653 struct command_line *l;
655 t = get_tracepoint_by_number (&args, NULL, 1);
659 xstrprintf ("Enter actions for tracepoint %d, one per line.",
661 struct cleanup *cleanups = make_cleanup (xfree, tmpbuf);
663 l = read_command_lines (tmpbuf, from_tty, 1,
664 check_tracepoint_command, t);
665 do_cleanups (cleanups);
666 breakpoint_set_commands (&t->base, l);
668 /* else just return */
671 /* Report the results of checking the agent expression, as errors or
675 report_agent_reqs_errors (struct agent_expr *aexpr)
677 /* All of the "flaws" are serious bytecode generation issues that
678 should never occur. */
679 if (aexpr->flaw != agent_flaw_none)
680 internal_error (__FILE__, __LINE__, _("expression is malformed"));
682 /* If analysis shows a stack underflow, GDB must have done something
683 badly wrong in its bytecode generation. */
684 if (aexpr->min_height < 0)
685 internal_error (__FILE__, __LINE__,
686 _("expression has min height < 0"));
688 /* Issue this error if the stack is predicted to get too deep. The
689 limit is rather arbitrary; a better scheme might be for the
690 target to report how much stack it will have available. The
691 depth roughly corresponds to parenthesization, so a limit of 20
692 amounts to 20 levels of expression nesting, which is actually
693 a pretty big hairy expression. */
694 if (aexpr->max_height > 20)
695 error (_("Expression is too complicated."));
698 /* worker function */
700 validate_actionline (const char *line, struct breakpoint *b)
702 struct cmd_list_element *c;
703 struct expression *exp = NULL;
704 struct cleanup *old_chain = NULL;
707 struct bp_location *loc;
708 struct agent_expr *aexpr;
709 struct tracepoint *t = (struct tracepoint *) b;
711 /* If EOF is typed, *line is NULL. */
715 p = skip_spaces_const (line);
717 /* Symbol lookup etc. */
718 if (*p == '\0') /* empty line: just prompt for another line. */
721 if (*p == '#') /* comment line */
724 c = lookup_cmd (&p, cmdlist, "", -1, 1);
726 error (_("`%s' is not a tracepoint action, or is ambiguous."), p);
728 if (cmd_cfunc_eq (c, collect_pseudocommand))
730 int trace_string = 0;
733 p = decode_agent_options (p, &trace_string);
736 { /* Repeat over a comma-separated list. */
737 QUIT; /* Allow user to bail out with ^C. */
738 p = skip_spaces_const (p);
740 if (*p == '$') /* Look for special pseudo-symbols. */
742 if (0 == strncasecmp ("reg", p + 1, 3)
743 || 0 == strncasecmp ("arg", p + 1, 3)
744 || 0 == strncasecmp ("loc", p + 1, 3)
745 || 0 == strncasecmp ("_ret", p + 1, 4)
746 || 0 == strncasecmp ("_sdata", p + 1, 6))
751 /* else fall thru, treat p as an expression and parse it! */
754 for (loc = t->base.loc; loc; loc = loc->next)
757 exp = parse_exp_1 (&p, loc->address,
758 block_for_pc (loc->address), 1);
759 old_chain = make_cleanup (free_current_contents, &exp);
761 if (exp->elts[0].opcode == OP_VAR_VALUE)
763 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
765 error (_("constant `%s' (value %s) "
766 "will not be collected."),
767 SYMBOL_PRINT_NAME (exp->elts[2].symbol),
768 plongest (SYMBOL_VALUE (exp->elts[2].symbol)));
770 else if (SYMBOL_CLASS (exp->elts[2].symbol)
771 == LOC_OPTIMIZED_OUT)
773 error (_("`%s' is optimized away "
774 "and cannot be collected."),
775 SYMBOL_PRINT_NAME (exp->elts[2].symbol));
779 /* We have something to collect, make sure that the expr to
780 bytecode translator can handle it and that it's not too
782 aexpr = gen_trace_for_expr (loc->address, exp, trace_string);
783 make_cleanup_free_agent_expr (aexpr);
785 if (aexpr->len > MAX_AGENT_EXPR_LEN)
786 error (_("Expression is too complicated."));
790 report_agent_reqs_errors (aexpr);
792 do_cleanups (old_chain);
795 while (p && *p++ == ',');
798 else if (cmd_cfunc_eq (c, teval_pseudocommand))
801 { /* Repeat over a comma-separated list. */
802 QUIT; /* Allow user to bail out with ^C. */
803 p = skip_spaces_const (p);
806 for (loc = t->base.loc; loc; loc = loc->next)
810 /* Only expressions are allowed for this action. */
811 exp = parse_exp_1 (&p, loc->address,
812 block_for_pc (loc->address), 1);
813 old_chain = make_cleanup (free_current_contents, &exp);
815 /* We have something to evaluate, make sure that the expr to
816 bytecode translator can handle it and that it's not too
818 aexpr = gen_eval_for_expr (loc->address, exp);
819 make_cleanup_free_agent_expr (aexpr);
821 if (aexpr->len > MAX_AGENT_EXPR_LEN)
822 error (_("Expression is too complicated."));
825 report_agent_reqs_errors (aexpr);
827 do_cleanups (old_chain);
830 while (p && *p++ == ',');
833 else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
837 p = skip_spaces_const (p);
838 t->step_count = strtol (p, &endp, 0);
839 if (endp == p || t->step_count == 0)
840 error (_("while-stepping step count `%s' is malformed."), line);
844 else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
848 error (_("`%s' is not a supported tracepoint action."), line);
852 memrange_absolute = -1
857 int type; /* memrange_absolute for absolute memory range,
858 else basereg number. */
859 bfd_signed_vma start;
863 struct collection_list
865 unsigned char regs_mask[32]; /* room for up to 256 regs */
868 struct memrange *list;
869 long aexpr_listsize; /* size of array pointed to by expr_list elt */
871 struct agent_expr **aexpr_list;
873 /* True is the user requested a collection of "$_sdata", "static
877 tracepoint_list, stepping_list;
879 /* MEMRANGE functions: */
881 static int memrange_cmp (const void *, const void *);
883 /* Compare memranges for qsort. */
885 memrange_cmp (const void *va, const void *vb)
887 const struct memrange *a = va, *b = vb;
889 if (a->type < b->type)
891 if (a->type > b->type)
893 if (a->type == memrange_absolute)
895 if ((bfd_vma) a->start < (bfd_vma) b->start)
897 if ((bfd_vma) a->start > (bfd_vma) b->start)
902 if (a->start < b->start)
904 if (a->start > b->start)
910 /* Sort the memrange list using qsort, and merge adjacent memranges. */
912 memrange_sortmerge (struct collection_list *memranges)
916 qsort (memranges->list, memranges->next_memrange,
917 sizeof (struct memrange), memrange_cmp);
918 if (memranges->next_memrange > 0)
920 for (a = 0, b = 1; b < memranges->next_memrange; b++)
922 /* If memrange b overlaps or is adjacent to memrange a,
924 if (memranges->list[a].type == memranges->list[b].type
925 && memranges->list[b].start <= memranges->list[a].end)
927 if (memranges->list[b].end > memranges->list[a].end)
928 memranges->list[a].end = memranges->list[b].end;
929 continue; /* next b, same a */
933 memcpy (&memranges->list[a], &memranges->list[b],
934 sizeof (struct memrange));
936 memranges->next_memrange = a + 1;
940 /* Add a register to a collection list. */
942 add_register (struct collection_list *collection, unsigned int regno)
945 printf_filtered ("collect register %d\n", regno);
946 if (regno >= (8 * sizeof (collection->regs_mask)))
947 error (_("Internal: register number %d too large for tracepoint"),
949 collection->regs_mask[regno / 8] |= 1 << (regno % 8);
952 /* Add a memrange to a collection list. */
954 add_memrange (struct collection_list *memranges,
955 int type, bfd_signed_vma base,
960 printf_filtered ("(%d,", type);
962 printf_filtered (",%ld)\n", len);
965 /* type: memrange_absolute == memory, other n == basereg */
966 memranges->list[memranges->next_memrange].type = type;
967 /* base: addr if memory, offset if reg relative. */
968 memranges->list[memranges->next_memrange].start = base;
969 /* len: we actually save end (base + len) for convenience */
970 memranges->list[memranges->next_memrange].end = base + len;
971 memranges->next_memrange++;
972 if (memranges->next_memrange >= memranges->listsize)
974 memranges->listsize *= 2;
975 memranges->list = xrealloc (memranges->list,
976 memranges->listsize);
979 if (type != memrange_absolute) /* Better collect the base register! */
980 add_register (memranges, type);
983 /* Add a symbol to a collection list. */
985 collect_symbol (struct collection_list *collect,
987 struct gdbarch *gdbarch,
988 long frame_regno, long frame_offset,
994 bfd_signed_vma offset;
995 int treat_as_expr = 0;
997 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
998 switch (SYMBOL_CLASS (sym))
1001 printf_filtered ("%s: don't know symbol class %d\n",
1002 SYMBOL_PRINT_NAME (sym),
1003 SYMBOL_CLASS (sym));
1006 printf_filtered ("constant %s (value %s) will not be collected.\n",
1007 SYMBOL_PRINT_NAME (sym), plongest (SYMBOL_VALUE (sym)));
1010 offset = SYMBOL_VALUE_ADDRESS (sym);
1015 sprintf_vma (tmp, offset);
1016 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1017 SYMBOL_PRINT_NAME (sym), len,
1020 /* A struct may be a C++ class with static fields, go to general
1021 expression handling. */
1022 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
1025 add_memrange (collect, memrange_absolute, offset, len);
1028 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
1030 printf_filtered ("LOC_REG[parm] %s: ",
1031 SYMBOL_PRINT_NAME (sym));
1032 add_register (collect, reg);
1033 /* Check for doubles stored in two registers. */
1034 /* FIXME: how about larger types stored in 3 or more regs? */
1035 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
1036 len > register_size (gdbarch, reg))
1037 add_register (collect, reg + 1);
1040 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1041 printf_filtered (" (will not collect %s)\n",
1042 SYMBOL_PRINT_NAME (sym));
1046 offset = frame_offset + SYMBOL_VALUE (sym);
1049 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1050 SYMBOL_PRINT_NAME (sym), len);
1051 printf_vma (offset);
1052 printf_filtered (" from frame ptr reg %d\n", reg);
1054 add_memrange (collect, reg, offset, len);
1056 case LOC_REGPARM_ADDR:
1057 reg = SYMBOL_VALUE (sym);
1061 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1062 SYMBOL_PRINT_NAME (sym), len);
1063 printf_vma (offset);
1064 printf_filtered (" from reg %d\n", reg);
1066 add_memrange (collect, reg, offset, len);
1070 offset = frame_offset + SYMBOL_VALUE (sym);
1073 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1074 SYMBOL_PRINT_NAME (sym), len);
1075 printf_vma (offset);
1076 printf_filtered (" from frame ptr reg %d\n", reg);
1078 add_memrange (collect, reg, offset, len);
1081 case LOC_UNRESOLVED:
1085 case LOC_OPTIMIZED_OUT:
1086 printf_filtered ("%s has been optimized out of existence.\n",
1087 SYMBOL_PRINT_NAME (sym));
1095 /* Expressions are the most general case. */
1098 struct agent_expr *aexpr;
1099 struct cleanup *old_chain1 = NULL;
1101 aexpr = gen_trace_for_var (scope, gdbarch, sym, trace_string);
1103 /* It can happen that the symbol is recorded as a computed
1104 location, but it's been optimized away and doesn't actually
1105 have a location expression. */
1108 printf_filtered ("%s has been optimized out of existence.\n",
1109 SYMBOL_PRINT_NAME (sym));
1113 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1117 report_agent_reqs_errors (aexpr);
1119 discard_cleanups (old_chain1);
1120 add_aexpr (collect, aexpr);
1122 /* Take care of the registers. */
1123 if (aexpr->reg_mask_len > 0)
1127 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1129 QUIT; /* Allow user to bail out with ^C. */
1130 if (aexpr->reg_mask[ndx1] != 0)
1132 /* Assume chars have 8 bits. */
1133 for (ndx2 = 0; ndx2 < 8; ndx2++)
1134 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1135 /* It's used -- record it. */
1136 add_register (collect, ndx1 * 8 + ndx2);
1143 /* Data to be passed around in the calls to the locals and args
1146 struct add_local_symbols_data
1148 struct collection_list *collect;
1149 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, p->trace_string);
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,
1178 struct block *block;
1179 struct add_local_symbols_data cb_data;
1181 cb_data.collect = collect;
1182 cb_data.gdbarch = gdbarch;
1184 cb_data.frame_regno = frame_regno;
1185 cb_data.frame_offset = frame_offset;
1187 cb_data.trace_string = trace_string;
1191 block = block_for_pc (pc);
1194 warning (_("Can't collect locals; "
1195 "no symbol table info available.\n"));
1199 iterate_over_block_local_vars (block, do_collect_symbol, &cb_data);
1200 if (cb_data.count == 0)
1201 warning (_("No locals found in scope."));
1205 pc = get_pc_function_start (pc);
1206 block = block_for_pc (pc);
1209 warning (_("Can't collect args; no symbol table info available."));
1213 iterate_over_block_arg_vars (block, do_collect_symbol, &cb_data);
1214 if (cb_data.count == 0)
1215 warning (_("No args found in scope."));
1220 add_static_trace_data (struct collection_list *collection)
1223 printf_filtered ("collect static trace data\n");
1224 collection->strace_data = 1;
1227 /* worker function */
1229 clear_collection_list (struct collection_list *list)
1233 list->next_memrange = 0;
1234 for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1236 free_agent_expr (list->aexpr_list[ndx]);
1237 list->aexpr_list[ndx] = NULL;
1239 list->next_aexpr_elt = 0;
1240 memset (list->regs_mask, 0, sizeof (list->regs_mask));
1241 list->strace_data = 0;
1244 /* Reduce a collection list to string form (for gdb protocol). */
1246 stringify_collection_list (struct collection_list *list)
1248 char temp_buf[2048];
1252 char *(*str_list)[];
1256 count = 1 + 1 + list->next_memrange + list->next_aexpr_elt + 1;
1257 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1259 if (list->strace_data)
1262 printf_filtered ("\nCollecting static trace data\n");
1265 (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
1269 for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1270 if (list->regs_mask[i] != 0) /* Skip leading zeroes in regs_mask. */
1272 if (list->regs_mask[i] != 0) /* Prepare to send regs_mask to the stub. */
1275 printf_filtered ("\nCollecting registers (mask): 0x");
1280 QUIT; /* Allow user to bail out with ^C. */
1282 printf_filtered ("%02X", list->regs_mask[i]);
1283 sprintf (end, "%02X", list->regs_mask[i]);
1286 (*str_list)[ndx] = xstrdup (temp_buf);
1290 printf_filtered ("\n");
1291 if (list->next_memrange > 0 && info_verbose)
1292 printf_filtered ("Collecting memranges: \n");
1293 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1295 QUIT; /* Allow user to bail out with ^C. */
1296 sprintf_vma (tmp2, list->list[i].start);
1299 printf_filtered ("(%d, %s, %ld)\n",
1302 (long) (list->list[i].end - list->list[i].start));
1304 if (count + 27 > MAX_AGENT_EXPR_LEN)
1306 (*str_list)[ndx] = savestring (temp_buf, count);
1313 bfd_signed_vma length = list->list[i].end - list->list[i].start;
1315 /* The "%X" conversion specifier expects an unsigned argument,
1316 so passing -1 (memrange_absolute) to it directly gives you
1317 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1319 if (list->list[i].type == memrange_absolute)
1320 sprintf (end, "M-1,%s,%lX", tmp2, (long) length);
1322 sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length);
1325 count += strlen (end);
1326 end = temp_buf + count;
1329 for (i = 0; i < list->next_aexpr_elt; i++)
1331 QUIT; /* Allow user to bail out with ^C. */
1332 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1334 (*str_list)[ndx] = savestring (temp_buf, count);
1339 sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1340 end += 10; /* 'X' + 8 hex digits + ',' */
1343 end = mem2hex (list->aexpr_list[i]->buf,
1344 end, list->aexpr_list[i]->len);
1345 count += 2 * list->aexpr_list[i]->len;
1350 (*str_list)[ndx] = savestring (temp_buf, count);
1355 (*str_list)[ndx] = NULL;
1368 encode_actions_1 (struct command_line *action,
1369 struct bp_location *tloc,
1371 LONGEST frame_offset,
1372 struct collection_list *collect,
1373 struct collection_list *stepping_list)
1375 const char *action_exp;
1376 struct expression *exp = NULL;
1378 struct value *tempval;
1379 struct cmd_list_element *cmd;
1380 struct agent_expr *aexpr;
1382 for (; action; action = action->next)
1384 QUIT; /* Allow user to bail out with ^C. */
1385 action_exp = action->line;
1386 action_exp = skip_spaces_const (action_exp);
1388 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1390 error (_("Bad action list item: %s"), action_exp);
1392 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1394 int trace_string = 0;
1396 if (*action_exp == '/')
1397 action_exp = decode_agent_options (action_exp, &trace_string);
1400 { /* Repeat over a comma-separated list. */
1401 QUIT; /* Allow user to bail out with ^C. */
1402 action_exp = skip_spaces_const (action_exp);
1404 if (0 == strncasecmp ("$reg", action_exp, 4))
1406 for (i = 0; i < gdbarch_num_regs (tloc->gdbarch); i++)
1407 add_register (collect, i);
1408 action_exp = strchr (action_exp, ','); /* more? */
1410 else if (0 == strncasecmp ("$arg", action_exp, 4))
1412 add_local_symbols (collect,
1419 action_exp = strchr (action_exp, ','); /* more? */
1421 else if (0 == strncasecmp ("$loc", action_exp, 4))
1423 add_local_symbols (collect,
1430 action_exp = strchr (action_exp, ','); /* more? */
1432 else if (0 == strncasecmp ("$_ret", action_exp, 5))
1434 struct cleanup *old_chain1 = NULL;
1436 aexpr = gen_trace_for_return_address (tloc->address,
1440 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1443 report_agent_reqs_errors (aexpr);
1445 discard_cleanups (old_chain1);
1446 add_aexpr (collect, aexpr);
1448 /* take care of the registers */
1449 if (aexpr->reg_mask_len > 0)
1453 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1455 QUIT; /* allow user to bail out with ^C */
1456 if (aexpr->reg_mask[ndx1] != 0)
1458 /* assume chars have 8 bits */
1459 for (ndx2 = 0; ndx2 < 8; ndx2++)
1460 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1461 /* it's used -- record it */
1462 add_register (collect,
1468 action_exp = strchr (action_exp, ','); /* more? */
1470 else if (0 == strncasecmp ("$_sdata", action_exp, 7))
1472 add_static_trace_data (collect);
1473 action_exp = strchr (action_exp, ','); /* more? */
1478 struct cleanup *old_chain = NULL;
1479 struct cleanup *old_chain1 = NULL;
1481 exp = parse_exp_1 (&action_exp, tloc->address,
1482 block_for_pc (tloc->address), 1);
1483 old_chain = make_cleanup (free_current_contents, &exp);
1485 switch (exp->elts[0].opcode)
1489 const char *name = &exp->elts[2].string;
1491 i = user_reg_map_name_to_regnum (tloc->gdbarch,
1492 name, strlen (name));
1494 internal_error (__FILE__, __LINE__,
1495 _("Register $%s not available"),
1498 printf_filtered ("OP_REGISTER: ");
1499 add_register (collect, i);
1504 /* Safe because we know it's a simple expression. */
1505 tempval = evaluate_expression (exp);
1506 addr = value_address (tempval);
1507 /* Initialize the TYPE_LENGTH if it is a typedef. */
1508 check_typedef (exp->elts[1].type);
1509 add_memrange (collect, memrange_absolute, addr,
1510 TYPE_LENGTH (exp->elts[1].type));
1514 collect_symbol (collect,
1515 exp->elts[2].symbol,
1523 default: /* Full-fledged expression. */
1524 aexpr = gen_trace_for_expr (tloc->address, exp,
1527 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1531 report_agent_reqs_errors (aexpr);
1533 discard_cleanups (old_chain1);
1534 add_aexpr (collect, aexpr);
1536 /* Take care of the registers. */
1537 if (aexpr->reg_mask_len > 0)
1542 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1544 QUIT; /* Allow user to bail out with ^C. */
1545 if (aexpr->reg_mask[ndx1] != 0)
1547 /* Assume chars have 8 bits. */
1548 for (ndx2 = 0; ndx2 < 8; ndx2++)
1549 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1550 /* It's used -- record it. */
1551 add_register (collect,
1558 do_cleanups (old_chain);
1561 while (action_exp && *action_exp++ == ',');
1563 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1566 { /* Repeat over a comma-separated list. */
1567 QUIT; /* Allow user to bail out with ^C. */
1568 action_exp = skip_spaces_const (action_exp);
1571 struct cleanup *old_chain = NULL;
1572 struct cleanup *old_chain1 = NULL;
1574 exp = parse_exp_1 (&action_exp, tloc->address,
1575 block_for_pc (tloc->address), 1);
1576 old_chain = make_cleanup (free_current_contents, &exp);
1578 aexpr = gen_eval_for_expr (tloc->address, exp);
1579 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1582 report_agent_reqs_errors (aexpr);
1584 discard_cleanups (old_chain1);
1585 /* Even though we're not officially collecting, add
1586 to the collect list anyway. */
1587 add_aexpr (collect, aexpr);
1589 do_cleanups (old_chain);
1592 while (action_exp && *action_exp++ == ',');
1594 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1596 /* We check against nested while-stepping when setting
1597 breakpoint action, so no way to run into nested
1599 gdb_assert (stepping_list);
1601 encode_actions_1 (action->body_list[0], tloc, frame_reg,
1602 frame_offset, stepping_list, NULL);
1605 error (_("Invalid tracepoint command '%s'"), action->line);
1609 /* Render all actions into gdb protocol. */
1612 encode_actions (struct bp_location *tloc, char ***tdp_actions,
1613 char ***stepping_actions)
1615 char *default_collect_line = NULL;
1616 struct command_line *actions;
1617 struct command_line *default_collect_action = NULL;
1619 LONGEST frame_offset;
1620 struct cleanup *back_to;
1622 back_to = make_cleanup (null_cleanup, NULL);
1624 clear_collection_list (&tracepoint_list);
1625 clear_collection_list (&stepping_list);
1627 *tdp_actions = NULL;
1628 *stepping_actions = NULL;
1630 gdbarch_virtual_frame_pointer (tloc->gdbarch,
1631 tloc->address, &frame_reg, &frame_offset);
1633 actions = all_tracepoint_actions_and_cleanup (tloc->owner);
1635 encode_actions_1 (actions, tloc, frame_reg, frame_offset,
1636 &tracepoint_list, &stepping_list);
1638 memrange_sortmerge (&tracepoint_list);
1639 memrange_sortmerge (&stepping_list);
1641 *tdp_actions = stringify_collection_list (&tracepoint_list);
1642 *stepping_actions = stringify_collection_list (&stepping_list);
1644 do_cleanups (back_to);
1648 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
1650 if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1652 collect->aexpr_list =
1653 xrealloc (collect->aexpr_list,
1654 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
1655 collect->aexpr_listsize *= 2;
1657 collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1658 collect->next_aexpr_elt++;
1662 process_tracepoint_on_disconnect (void)
1664 VEC(breakpoint_p) *tp_vec = NULL;
1666 struct breakpoint *b;
1667 int has_pending_p = 0;
1669 /* Check whether we still have pending tracepoint. If we have, warn the
1670 user that pending tracepoint will no longer work. */
1671 tp_vec = all_tracepoints ();
1672 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1681 struct bp_location *loc1;
1683 for (loc1 = b->loc; loc1; loc1 = loc1->next)
1685 if (loc1->shlib_disabled)
1696 VEC_free (breakpoint_p, tp_vec);
1699 warning (_("Pending tracepoints will not be resolved while"
1700 " GDB is disconnected\n"));
1703 /* Reset local state of tracing. */
1706 trace_reset_local_state (void)
1708 set_traceframe_num (-1);
1709 set_tracepoint_num (-1);
1710 set_traceframe_context (NULL);
1711 clear_traceframe_info ();
1715 start_tracing (char *notes)
1717 VEC(breakpoint_p) *tp_vec = NULL;
1719 struct breakpoint *b;
1720 struct trace_state_variable *tsv;
1721 int any_enabled = 0, num_to_download = 0;
1724 tp_vec = all_tracepoints ();
1726 /* No point in tracing without any tracepoints... */
1727 if (VEC_length (breakpoint_p, tp_vec) == 0)
1729 VEC_free (breakpoint_p, tp_vec);
1730 error (_("No tracepoints defined, not starting trace"));
1733 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1735 struct tracepoint *t = (struct tracepoint *) b;
1736 struct bp_location *loc;
1738 if (b->enable_state == bp_enabled)
1741 if ((b->type == bp_fast_tracepoint
1742 ? may_insert_fast_tracepoints
1743 : may_insert_tracepoints))
1746 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1747 (b->type == bp_fast_tracepoint ? "fast " : ""), b->number);
1752 if (target_supports_enable_disable_tracepoint ())
1753 warning (_("No tracepoints enabled"));
1756 /* No point in tracing with only disabled tracepoints that
1757 cannot be re-enabled. */
1758 VEC_free (breakpoint_p, tp_vec);
1759 error (_("No tracepoints enabled, not starting trace"));
1763 if (num_to_download <= 0)
1765 VEC_free (breakpoint_p, tp_vec);
1766 error (_("No tracepoints that may be downloaded, not starting trace"));
1769 target_trace_init ();
1771 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1773 struct tracepoint *t = (struct tracepoint *) b;
1774 struct bp_location *loc;
1775 int bp_location_downloaded = 0;
1777 /* Clear `inserted' flag. */
1778 for (loc = b->loc; loc; loc = loc->next)
1781 if ((b->type == bp_fast_tracepoint
1782 ? !may_insert_fast_tracepoints
1783 : !may_insert_tracepoints))
1786 t->number_on_target = 0;
1788 for (loc = b->loc; loc; loc = loc->next)
1790 /* Since tracepoint locations are never duplicated, `inserted'
1791 flag should be zero. */
1792 gdb_assert (!loc->inserted);
1794 target_download_tracepoint (loc);
1797 bp_location_downloaded = 1;
1800 t->number_on_target = b->number;
1802 for (loc = b->loc; loc; loc = loc->next)
1803 if (loc->probe != NULL)
1804 loc->probe->pops->set_semaphore (loc->probe, loc->gdbarch);
1806 if (bp_location_downloaded)
1807 observer_notify_breakpoint_modified (b);
1809 VEC_free (breakpoint_p, tp_vec);
1811 /* Send down all the trace state variables too. */
1812 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1814 target_download_trace_state_variable (tsv);
1817 /* Tell target to treat text-like sections as transparent. */
1818 target_trace_set_readonly_regions ();
1819 /* Set some mode flags. */
1820 target_set_disconnected_tracing (disconnected_tracing);
1821 target_set_circular_trace_buffer (circular_trace_buffer);
1822 target_set_trace_buffer_size (trace_buffer_size);
1825 notes = trace_notes;
1826 ret = target_set_trace_notes (trace_user, notes, NULL);
1828 if (!ret && (trace_user || notes))
1829 warning (_("Target does not support trace user/notes, info ignored"));
1831 /* Now insert traps and begin collecting data. */
1832 target_trace_start ();
1834 /* Reset our local state. */
1835 trace_reset_local_state ();
1836 current_trace_status()->running = 1;
1839 /* The tstart command requests the target to start a new trace run.
1840 The command passes any arguments it has to the target verbatim, as
1841 an optional "trace note". This is useful as for instance a warning
1842 to other users if the trace runs disconnected, and you don't want
1843 anybody else messing with the target. */
1846 trace_start_command (char *args, int from_tty)
1848 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1850 if (current_trace_status ()->running)
1853 && !query (_("A trace is running already. Start a new run? ")))
1854 error (_("New trace run not started."));
1857 start_tracing (args);
1860 /* The tstop command stops the tracing run. The command passes any
1861 supplied arguments to the target verbatim as a "stop note"; if the
1862 target supports trace notes, then it will be reported back as part
1863 of the trace run's status. */
1866 trace_stop_command (char *args, int from_tty)
1868 if (!current_trace_status ()->running)
1869 error (_("Trace is not running."));
1871 stop_tracing (args);
1875 stop_tracing (char *note)
1878 VEC(breakpoint_p) *tp_vec = NULL;
1880 struct breakpoint *t;
1882 target_trace_stop ();
1884 tp_vec = all_tracepoints ();
1885 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1887 struct bp_location *loc;
1889 if ((t->type == bp_fast_tracepoint
1890 ? !may_insert_fast_tracepoints
1891 : !may_insert_tracepoints))
1894 for (loc = t->loc; loc; loc = loc->next)
1896 /* GDB can be totally absent in some disconnected trace scenarios,
1897 but we don't really care if this semaphore goes out of sync.
1898 That's why we are decrementing it here, but not taking care
1900 if (loc->probe != NULL)
1901 loc->probe->pops->clear_semaphore (loc->probe, loc->gdbarch);
1905 VEC_free (breakpoint_p, tp_vec);
1908 note = trace_stop_notes;
1909 ret = target_set_trace_notes (NULL, NULL, note);
1912 warning (_("Target does not support trace notes, note ignored"));
1914 /* Should change in response to reply? */
1915 current_trace_status ()->running = 0;
1918 /* tstatus command */
1920 trace_status_command (char *args, int from_tty)
1922 struct trace_status *ts = current_trace_status ();
1924 VEC(breakpoint_p) *tp_vec = NULL;
1925 struct breakpoint *t;
1927 status = target_get_trace_status (ts);
1931 if (ts->filename != NULL)
1932 printf_filtered (_("Using a trace file.\n"));
1935 printf_filtered (_("Trace can not be run on this target.\n"));
1940 if (!ts->running_known)
1942 printf_filtered (_("Run/stop status is unknown.\n"));
1944 else if (ts->running)
1946 printf_filtered (_("Trace is running on the target.\n"));
1950 switch (ts->stop_reason)
1952 case trace_never_run:
1953 printf_filtered (_("No trace has been run on the target.\n"));
1957 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1960 printf_filtered (_("Trace stopped by a tstop command.\n"));
1962 case trace_buffer_full:
1963 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1965 case trace_disconnected:
1966 printf_filtered (_("Trace stopped because of disconnection.\n"));
1968 case tracepoint_passcount:
1969 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1970 ts->stopping_tracepoint);
1972 case tracepoint_error:
1973 if (ts->stopping_tracepoint)
1974 printf_filtered (_("Trace stopped by an "
1975 "error (%s, tracepoint %d).\n"),
1976 ts->stop_desc, ts->stopping_tracepoint);
1978 printf_filtered (_("Trace stopped by an error (%s).\n"),
1981 case trace_stop_reason_unknown:
1982 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1985 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1991 if (ts->traceframes_created >= 0
1992 && ts->traceframe_count != ts->traceframes_created)
1994 printf_filtered (_("Buffer contains %d trace "
1995 "frames (of %d created total).\n"),
1996 ts->traceframe_count, ts->traceframes_created);
1998 else if (ts->traceframe_count >= 0)
2000 printf_filtered (_("Collected %d trace frames.\n"),
2001 ts->traceframe_count);
2004 if (ts->buffer_free >= 0)
2006 if (ts->buffer_size >= 0)
2008 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2009 ts->buffer_free, ts->buffer_size);
2010 if (ts->buffer_size > 0)
2011 printf_filtered (_(" (%d%% full)"),
2012 ((int) ((((long long) (ts->buffer_size
2013 - ts->buffer_free)) * 100)
2014 / ts->buffer_size)));
2015 printf_filtered (_(".\n"));
2018 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2022 if (ts->disconnected_tracing)
2023 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2025 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2027 if (ts->circular_buffer)
2028 printf_filtered (_("Trace buffer is circular.\n"));
2030 if (ts->user_name && strlen (ts->user_name) > 0)
2031 printf_filtered (_("Trace user is %s.\n"), ts->user_name);
2033 if (ts->notes && strlen (ts->notes) > 0)
2034 printf_filtered (_("Trace notes: %s.\n"), ts->notes);
2036 /* Now report on what we're doing with tfind. */
2037 if (traceframe_number >= 0)
2038 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2039 traceframe_number, tracepoint_number);
2041 printf_filtered (_("Not looking at any trace frame.\n"));
2043 /* Report start/stop times if supplied. */
2048 LONGEST run_time = ts->stop_time - ts->start_time;
2050 /* Reporting a run time is more readable than two long numbers. */
2051 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2052 (long int) ts->start_time / 1000000,
2053 (long int) ts->start_time % 1000000,
2054 (long int) run_time / 1000000,
2055 (long int) run_time % 1000000);
2058 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2059 (long int) ts->start_time / 1000000,
2060 (long int) ts->start_time % 1000000);
2062 else if (ts->stop_time)
2063 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2064 (long int) ts->stop_time / 1000000,
2065 (long int) ts->stop_time % 1000000);
2067 /* Now report any per-tracepoint status available. */
2068 tp_vec = all_tracepoints ();
2070 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
2071 target_get_tracepoint_status (t, NULL);
2073 VEC_free (breakpoint_p, tp_vec);
2076 /* Report the trace status to uiout, in a way suitable for MI, and not
2077 suitable for CLI. If ON_STOP is true, suppress a few fields that
2078 are not meaningful in the -trace-stop response.
2080 The implementation is essentially parallel to trace_status_command, but
2081 merging them will result in unreadable code. */
2083 trace_status_mi (int on_stop)
2085 struct ui_out *uiout = current_uiout;
2086 struct trace_status *ts = current_trace_status ();
2089 status = target_get_trace_status (ts);
2091 if (status == -1 && ts->filename == NULL)
2093 ui_out_field_string (uiout, "supported", "0");
2097 if (ts->filename != NULL)
2098 ui_out_field_string (uiout, "supported", "file");
2100 ui_out_field_string (uiout, "supported", "1");
2102 if (ts->filename != NULL)
2103 ui_out_field_string (uiout, "trace-file", ts->filename);
2105 gdb_assert (ts->running_known);
2109 ui_out_field_string (uiout, "running", "1");
2111 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2112 Given that the frontend gets the status either on -trace-stop, or from
2113 -trace-status after re-connection, it does not seem like this
2114 information is necessary for anything. It is not necessary for either
2115 figuring the vital state of the target nor for navigation of trace
2116 frames. If the frontend wants to show the current state is some
2117 configure dialog, it can request the value when such dialog is
2118 invoked by the user. */
2122 char *stop_reason = NULL;
2123 int stopping_tracepoint = -1;
2126 ui_out_field_string (uiout, "running", "0");
2128 if (ts->stop_reason != trace_stop_reason_unknown)
2130 switch (ts->stop_reason)
2133 stop_reason = "request";
2135 case trace_buffer_full:
2136 stop_reason = "overflow";
2138 case trace_disconnected:
2139 stop_reason = "disconnection";
2141 case tracepoint_passcount:
2142 stop_reason = "passcount";
2143 stopping_tracepoint = ts->stopping_tracepoint;
2145 case tracepoint_error:
2146 stop_reason = "error";
2147 stopping_tracepoint = ts->stopping_tracepoint;
2153 ui_out_field_string (uiout, "stop-reason", stop_reason);
2154 if (stopping_tracepoint != -1)
2155 ui_out_field_int (uiout, "stopping-tracepoint",
2156 stopping_tracepoint);
2157 if (ts->stop_reason == tracepoint_error)
2158 ui_out_field_string (uiout, "error-description",
2164 if (ts->traceframe_count != -1)
2165 ui_out_field_int (uiout, "frames", ts->traceframe_count);
2166 if (ts->traceframes_created != -1)
2167 ui_out_field_int (uiout, "frames-created", ts->traceframes_created);
2168 if (ts->buffer_size != -1)
2169 ui_out_field_int (uiout, "buffer-size", ts->buffer_size);
2170 if (ts->buffer_free != -1)
2171 ui_out_field_int (uiout, "buffer-free", ts->buffer_free);
2173 ui_out_field_int (uiout, "disconnected", ts->disconnected_tracing);
2174 ui_out_field_int (uiout, "circular", ts->circular_buffer);
2176 ui_out_field_string (uiout, "user-name", ts->user_name);
2177 ui_out_field_string (uiout, "notes", ts->notes);
2182 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2183 (long int) ts->start_time / 1000000,
2184 (long int) ts->start_time % 1000000);
2185 ui_out_field_string (uiout, "start-time", buf);
2186 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2187 (long int) ts->stop_time / 1000000,
2188 (long int) ts->stop_time % 1000000);
2189 ui_out_field_string (uiout, "stop-time", buf);
2193 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2194 user if she really wants to detach. */
2197 query_if_trace_running (int from_tty)
2202 /* It can happen that the target that was tracing went away on its
2203 own, and we didn't notice. Get a status update, and if the
2204 current target doesn't even do tracing, then assume it's not
2206 if (target_get_trace_status (current_trace_status ()) < 0)
2207 current_trace_status ()->running = 0;
2209 /* If running interactively, give the user the option to cancel and
2210 then decide what to do differently with the run. Scripts are
2211 just going to disconnect and let the target deal with it,
2212 according to how it's been instructed previously via
2213 disconnected-tracing. */
2214 if (current_trace_status ()->running)
2216 process_tracepoint_on_disconnect ();
2218 if (current_trace_status ()->disconnected_tracing)
2220 if (!query (_("Trace is running and will "
2221 "continue after detach; detach anyway? ")))
2222 error (_("Not confirmed."));
2226 if (!query (_("Trace is running but will "
2227 "stop on detach; detach anyway? ")))
2228 error (_("Not confirmed."));
2233 /* This function handles the details of what to do about an ongoing
2234 tracing run if the user has asked to detach or otherwise disconnect
2238 disconnect_tracing (void)
2240 /* Also we want to be out of tfind mode, otherwise things can get
2241 confusing upon reconnection. Just use these calls instead of
2242 full tfind_1 behavior because we're in the middle of detaching,
2243 and there's no point to updating current stack frame etc. */
2244 trace_reset_local_state ();
2247 /* Worker function for the various flavors of the tfind command. */
2249 tfind_1 (enum trace_find_type type, int num,
2250 CORE_ADDR addr1, CORE_ADDR addr2,
2253 int target_frameno = -1, target_tracept = -1;
2254 struct frame_id old_frame_id = null_frame_id;
2255 struct tracepoint *tp;
2256 struct ui_out *uiout = current_uiout;
2258 /* Only try to get the current stack frame if we have a chance of
2259 succeeding. In particular, if we're trying to get a first trace
2260 frame while all threads are running, it's not going to succeed,
2261 so leave it with a default value and let the frame comparison
2262 below (correctly) decide to print out the source location of the
2264 if (!(type == tfind_number && num == -1)
2265 && (has_stack_frames () || traceframe_number >= 0))
2266 old_frame_id = get_frame_id (get_current_frame ());
2268 target_frameno = target_trace_find (type, num, addr1, addr2,
2271 if (type == tfind_number
2273 && target_frameno == -1)
2275 /* We told the target to get out of tfind mode, and it did. */
2277 else if (target_frameno == -1)
2279 /* A request for a non-existent trace frame has failed.
2280 Our response will be different, depending on FROM_TTY:
2282 If FROM_TTY is true, meaning that this command was
2283 typed interactively by the user, then give an error
2284 and DO NOT change the state of traceframe_number etc.
2286 However if FROM_TTY is false, meaning that we're either
2287 in a script, a loop, or a user-defined command, then
2288 DON'T give an error, but DO change the state of
2289 traceframe_number etc. to invalid.
2291 The rationalle is that if you typed the command, you
2292 might just have committed a typo or something, and you'd
2293 like to NOT lose your current debugging state. However
2294 if you're in a user-defined command or especially in a
2295 loop, then you need a way to detect that the command
2296 failed WITHOUT aborting. This allows you to write
2297 scripts that search thru the trace buffer until the end,
2298 and then continue on to do something else. */
2301 error (_("Target failed to find requested trace frame."));
2305 printf_filtered ("End of trace buffer.\n");
2306 #if 0 /* dubious now? */
2307 /* The following will not recurse, since it's
2309 trace_find_command ("-1", from_tty);
2314 tp = get_tracepoint_by_number_on_target (target_tracept);
2316 reinit_frame_cache ();
2317 target_dcache_invalidate ();
2319 set_tracepoint_num (tp ? tp->base.number : target_tracept);
2321 if (target_frameno != get_traceframe_number ())
2322 observer_notify_traceframe_changed (target_frameno, tracepoint_number);
2324 set_current_traceframe (target_frameno);
2326 if (target_frameno == -1)
2327 set_traceframe_context (NULL);
2329 set_traceframe_context (get_current_frame ());
2331 if (traceframe_number >= 0)
2333 /* Use different branches for MI and CLI to make CLI messages
2335 if (ui_out_is_mi_like_p (uiout))
2337 ui_out_field_string (uiout, "found", "1");
2338 ui_out_field_int (uiout, "tracepoint", tracepoint_number);
2339 ui_out_field_int (uiout, "traceframe", traceframe_number);
2343 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2344 traceframe_number, tracepoint_number);
2349 if (ui_out_is_mi_like_p (uiout))
2350 ui_out_field_string (uiout, "found", "0");
2351 else if (type == tfind_number && num == -1)
2352 printf_unfiltered (_("No longer looking at any trace frame\n"));
2353 else /* This case may never occur, check. */
2354 printf_unfiltered (_("No trace frame found\n"));
2357 /* If we're in nonstop mode and getting out of looking at trace
2358 frames, there won't be any current frame to go back to and
2361 && (has_stack_frames () || traceframe_number >= 0))
2363 enum print_what print_what;
2365 /* NOTE: in imitation of the step command, try to determine
2366 whether we have made a transition from one function to
2367 another. If so, we'll print the "stack frame" (ie. the new
2368 function and it's arguments) -- otherwise we'll just show the
2371 if (frame_id_eq (old_frame_id,
2372 get_frame_id (get_current_frame ())))
2373 print_what = SRC_LINE;
2375 print_what = SRC_AND_LOC;
2377 print_stack_frame (get_selected_frame (NULL), 1, print_what);
2382 /* trace_find_command takes a trace frame number n,
2383 sends "QTFrame:<n>" to the target,
2384 and accepts a reply that may contain several optional pieces
2385 of information: a frame number, a tracepoint number, and an
2386 indication of whether this is a trap frame or a stepping frame.
2388 The minimal response is just "OK" (which indicates that the
2389 target does not give us a frame number or a tracepoint number).
2390 Instead of that, the target may send us a string containing
2392 F<hexnum> (gives the selected frame number)
2393 T<hexnum> (gives the selected tracepoint number)
2398 trace_find_command (char *args, int from_tty)
2399 { /* This should only be called with a numeric argument. */
2402 if (current_trace_status ()->running
2403 && current_trace_status ()->filename == NULL)
2404 error (_("May not look at trace frames while trace is running."));
2406 if (args == 0 || *args == 0)
2407 { /* TFIND with no args means find NEXT trace frame. */
2408 if (traceframe_number == -1)
2409 frameno = 0; /* "next" is first one. */
2411 frameno = traceframe_number + 1;
2413 else if (0 == strcmp (args, "-"))
2415 if (traceframe_number == -1)
2416 error (_("not debugging trace buffer"));
2417 else if (from_tty && traceframe_number == 0)
2418 error (_("already at start of trace buffer"));
2420 frameno = traceframe_number - 1;
2422 /* A hack to work around eval's need for fp to have been collected. */
2423 else if (0 == strcmp (args, "-1"))
2426 frameno = parse_and_eval_long (args);
2429 error (_("invalid input (%d is less than zero)"), frameno);
2431 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2436 trace_find_end_command (char *args, int from_tty)
2438 trace_find_command ("-1", from_tty);
2443 trace_find_start_command (char *args, int from_tty)
2445 trace_find_command ("0", from_tty);
2448 /* tfind pc command */
2450 trace_find_pc_command (char *args, int from_tty)
2454 if (current_trace_status ()->running
2455 && current_trace_status ()->filename == NULL)
2456 error (_("May not look at trace frames while trace is running."));
2458 if (args == 0 || *args == 0)
2459 pc = regcache_read_pc (get_current_regcache ());
2461 pc = parse_and_eval_address (args);
2463 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2466 /* tfind tracepoint command */
2468 trace_find_tracepoint_command (char *args, int from_tty)
2471 struct tracepoint *tp;
2473 if (current_trace_status ()->running
2474 && current_trace_status ()->filename == NULL)
2475 error (_("May not look at trace frames while trace is running."));
2477 if (args == 0 || *args == 0)
2479 if (tracepoint_number == -1)
2480 error (_("No current tracepoint -- please supply an argument."));
2482 tdp = tracepoint_number; /* Default is current TDP. */
2485 tdp = parse_and_eval_long (args);
2487 /* If we have the tracepoint on hand, use the number that the
2488 target knows about (which may be different if we disconnected
2489 and reconnected). */
2490 tp = get_tracepoint (tdp);
2492 tdp = tp->number_on_target;
2494 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2497 /* TFIND LINE command:
2499 This command will take a sourceline for argument, just like BREAK
2500 or TRACE (ie. anything that "decode_line_1" can handle).
2502 With no argument, this command will find the next trace frame
2503 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2506 trace_find_line_command (char *args, int from_tty)
2508 static CORE_ADDR start_pc, end_pc;
2509 struct symtabs_and_lines sals;
2510 struct symtab_and_line sal;
2511 struct cleanup *old_chain;
2513 if (current_trace_status ()->running
2514 && current_trace_status ()->filename == NULL)
2515 error (_("May not look at trace frames while trace is running."));
2517 if (args == 0 || *args == 0)
2519 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2521 sals.sals = (struct symtab_and_line *)
2522 xmalloc (sizeof (struct symtab_and_line));
2527 sals = decode_line_with_current_source (args, DECODE_LINE_FUNFIRSTLINE);
2531 old_chain = make_cleanup (xfree, sals.sals);
2532 if (sal.symtab == 0)
2533 error (_("No line number information available."));
2535 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2537 if (start_pc == end_pc)
2539 printf_filtered ("Line %d of \"%s\"",
2541 symtab_to_filename_for_display (sal.symtab));
2543 printf_filtered (" is at address ");
2544 print_address (get_current_arch (), start_pc, gdb_stdout);
2546 printf_filtered (" but contains no code.\n");
2547 sal = find_pc_line (start_pc, 0);
2549 && find_line_pc_range (sal, &start_pc, &end_pc)
2550 && start_pc != end_pc)
2551 printf_filtered ("Attempting to find line %d instead.\n",
2554 error (_("Cannot find a good line."));
2558 /* Is there any case in which we get here, and have an address
2559 which the user would want to see? If we have debugging
2560 symbols and no line numbers? */
2561 error (_("Line number %d is out of range for \"%s\"."),
2562 sal.line, symtab_to_filename_for_display (sal.symtab));
2564 /* Find within range of stated line. */
2566 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2568 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2569 do_cleanups (old_chain);
2572 /* tfind range command */
2574 trace_find_range_command (char *args, int from_tty)
2576 static CORE_ADDR start, stop;
2579 if (current_trace_status ()->running
2580 && current_trace_status ()->filename == NULL)
2581 error (_("May not look at trace frames while trace is running."));
2583 if (args == 0 || *args == 0)
2584 { /* XXX FIXME: what should default behavior be? */
2585 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2589 if (0 != (tmp = strchr (args, ',')))
2591 *tmp++ = '\0'; /* Terminate start address. */
2592 tmp = skip_spaces (tmp);
2593 start = parse_and_eval_address (args);
2594 stop = parse_and_eval_address (tmp);
2597 { /* No explicit end address? */
2598 start = parse_and_eval_address (args);
2599 stop = start + 1; /* ??? */
2602 tfind_1 (tfind_range, 0, start, stop, from_tty);
2605 /* tfind outside command */
2607 trace_find_outside_command (char *args, int from_tty)
2609 CORE_ADDR start, stop;
2612 if (current_trace_status ()->running
2613 && current_trace_status ()->filename == NULL)
2614 error (_("May not look at trace frames while trace is running."));
2616 if (args == 0 || *args == 0)
2617 { /* XXX FIXME: what should default behavior be? */
2618 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2622 if (0 != (tmp = strchr (args, ',')))
2624 *tmp++ = '\0'; /* Terminate start address. */
2625 tmp = skip_spaces (tmp);
2626 start = parse_and_eval_address (args);
2627 stop = parse_and_eval_address (tmp);
2630 { /* No explicit end address? */
2631 start = parse_and_eval_address (args);
2632 stop = start + 1; /* ??? */
2635 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2638 /* info scope command: list the locals for a scope. */
2640 scope_info (char *args, int from_tty)
2642 struct symtabs_and_lines sals;
2644 struct minimal_symbol *msym;
2645 struct block *block;
2646 const char *symname;
2647 char *save_args = args;
2648 struct block_iterator iter;
2650 struct gdbarch *gdbarch;
2653 if (args == 0 || *args == 0)
2654 error (_("requires an argument (function, "
2655 "line or *addr) to define a scope"));
2657 sals = decode_line_1 (&args, DECODE_LINE_FUNFIRSTLINE, NULL, 0);
2658 if (sals.nelts == 0)
2659 return; /* Presumably decode_line_1 has already warned. */
2661 /* Resolve line numbers to PC. */
2662 resolve_sal_pc (&sals.sals[0]);
2663 block = block_for_pc (sals.sals[0].pc);
2667 QUIT; /* Allow user to bail out with ^C. */
2668 ALL_BLOCK_SYMBOLS (block, iter, sym)
2670 QUIT; /* Allow user to bail out with ^C. */
2672 printf_filtered ("Scope for %s:\n", save_args);
2675 symname = SYMBOL_PRINT_NAME (sym);
2676 if (symname == NULL || *symname == '\0')
2677 continue; /* Probably botched, certainly useless. */
2679 gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
2681 printf_filtered ("Symbol %s is ", symname);
2683 if (SYMBOL_COMPUTED_OPS (sym) != NULL)
2684 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2685 BLOCK_START (block),
2689 switch (SYMBOL_CLASS (sym))
2692 case LOC_UNDEF: /* Messed up symbol? */
2693 printf_filtered ("a bogus symbol, class %d.\n",
2694 SYMBOL_CLASS (sym));
2695 count--; /* Don't count this one. */
2698 printf_filtered ("a constant with value %s (%s)",
2699 plongest (SYMBOL_VALUE (sym)),
2700 hex_string (SYMBOL_VALUE (sym)));
2702 case LOC_CONST_BYTES:
2703 printf_filtered ("constant bytes: ");
2704 if (SYMBOL_TYPE (sym))
2705 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2706 fprintf_filtered (gdb_stdout, " %02x",
2707 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2710 printf_filtered ("in static storage at address ");
2711 printf_filtered ("%s", paddress (gdbarch,
2712 SYMBOL_VALUE_ADDRESS (sym)));
2715 /* GDBARCH is the architecture associated with the objfile
2716 the symbol is defined in; the target architecture may be
2717 different, and may provide additional registers. However,
2718 we do not know the target architecture at this point.
2719 We assume the objfile architecture will contain all the
2720 standard registers that occur in debug info in that
2722 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2725 if (SYMBOL_IS_ARGUMENT (sym))
2726 printf_filtered ("an argument in register $%s",
2727 gdbarch_register_name (gdbarch, regno));
2729 printf_filtered ("a local variable in register $%s",
2730 gdbarch_register_name (gdbarch, regno));
2733 printf_filtered ("an argument at stack/frame offset %s",
2734 plongest (SYMBOL_VALUE (sym)));
2737 printf_filtered ("a local variable at frame offset %s",
2738 plongest (SYMBOL_VALUE (sym)));
2741 printf_filtered ("a reference argument at offset %s",
2742 plongest (SYMBOL_VALUE (sym)));
2744 case LOC_REGPARM_ADDR:
2745 /* Note comment at LOC_REGISTER. */
2746 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2748 printf_filtered ("the address of an argument, in register $%s",
2749 gdbarch_register_name (gdbarch, regno));
2752 printf_filtered ("a typedef.\n");
2755 printf_filtered ("a label at address ");
2756 printf_filtered ("%s", paddress (gdbarch,
2757 SYMBOL_VALUE_ADDRESS (sym)));
2760 printf_filtered ("a function at address ");
2761 printf_filtered ("%s",
2762 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2764 case LOC_UNRESOLVED:
2765 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2768 printf_filtered ("Unresolved Static");
2771 printf_filtered ("static storage at address ");
2772 printf_filtered ("%s",
2774 SYMBOL_VALUE_ADDRESS (msym)));
2777 case LOC_OPTIMIZED_OUT:
2778 printf_filtered ("optimized out.\n");
2781 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2784 if (SYMBOL_TYPE (sym))
2785 printf_filtered (", length %d.\n",
2786 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2788 if (BLOCK_FUNCTION (block))
2791 block = BLOCK_SUPERBLOCK (block);
2794 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2798 /* Helper for trace_dump_command. Dump the action list starting at
2799 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2800 actions of the body of a while-stepping action. STEPPING_FRAME is
2801 set if the current traceframe was determined to be a while-stepping
2805 trace_dump_actions (struct command_line *action,
2806 int stepping_actions, int stepping_frame,
2809 const char *action_exp, *next_comma;
2811 for (; action != NULL; action = action->next)
2813 struct cmd_list_element *cmd;
2815 QUIT; /* Allow user to bail out with ^C. */
2816 action_exp = action->line;
2817 action_exp = skip_spaces_const (action_exp);
2819 /* The collection actions to be done while stepping are
2820 bracketed by the commands "while-stepping" and "end". */
2822 if (*action_exp == '#') /* comment line */
2825 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2827 error (_("Bad action list item: %s"), action_exp);
2829 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2833 for (i = 0; i < action->body_count; ++i)
2834 trace_dump_actions (action->body_list[i],
2835 1, stepping_frame, from_tty);
2837 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2839 /* Display the collected data.
2840 For the trap frame, display only what was collected at
2841 the trap. Likewise for stepping frames, display only
2842 what was collected while stepping. This means that the
2843 two boolean variables, STEPPING_FRAME and
2844 STEPPING_ACTIONS should be equal. */
2845 if (stepping_frame == stepping_actions)
2848 struct cleanup *old_chain
2849 = make_cleanup (free_current_contents, &cmd);
2850 int trace_string = 0;
2852 if (*action_exp == '/')
2853 action_exp = decode_agent_options (action_exp, &trace_string);
2856 { /* Repeat over a comma-separated list. */
2857 QUIT; /* Allow user to bail out with ^C. */
2858 if (*action_exp == ',')
2860 action_exp = skip_spaces_const (action_exp);
2862 next_comma = strchr (action_exp, ',');
2864 if (0 == strncasecmp (action_exp, "$reg", 4))
2865 registers_info (NULL, from_tty);
2866 else if (0 == strncasecmp (action_exp, "$_ret", 5))
2868 else if (0 == strncasecmp (action_exp, "$loc", 4))
2869 locals_info (NULL, from_tty);
2870 else if (0 == strncasecmp (action_exp, "$arg", 4))
2871 args_info (NULL, from_tty);
2874 if (next_comma != NULL)
2876 size_t len = next_comma - action_exp;
2878 cmd = xrealloc (cmd, len + 1);
2879 memcpy (cmd, action_exp, len);
2884 size_t len = strlen (action_exp);
2886 cmd = xrealloc (cmd, len + 1);
2887 memcpy (cmd, action_exp, len + 1);
2890 printf_filtered ("%s = ", cmd);
2891 output_command_const (cmd, from_tty);
2892 printf_filtered ("\n");
2894 action_exp = next_comma;
2896 while (action_exp && *action_exp == ',');
2898 do_cleanups (old_chain);
2904 /* Return all the actions, including default collect, of a tracepoint
2905 T. It constructs cleanups into the chain, and leaves the caller to
2906 handle them (call do_cleanups). */
2908 static struct command_line *
2909 all_tracepoint_actions_and_cleanup (struct breakpoint *t)
2911 struct command_line *actions;
2913 actions = breakpoint_commands (t);
2915 /* If there are default expressions to collect, make up a collect
2916 action and prepend to the action list to encode. Note that since
2917 validation is per-tracepoint (local var "xyz" might be valid for
2918 one tracepoint and not another, etc), we make up the action on
2919 the fly, and don't cache it. */
2920 if (*default_collect)
2922 struct command_line *default_collect_action;
2923 char *default_collect_line;
2925 default_collect_line = xstrprintf ("collect %s", default_collect);
2926 make_cleanup (xfree, default_collect_line);
2928 validate_actionline (default_collect_line, t);
2929 default_collect_action = xmalloc (sizeof (struct command_line));
2930 make_cleanup (xfree, default_collect_action);
2931 default_collect_action->next = actions;
2932 default_collect_action->line = default_collect_line;
2933 actions = default_collect_action;
2939 /* The tdump command. */
2942 trace_dump_command (char *args, int from_tty)
2944 struct regcache *regcache;
2945 struct tracepoint *t;
2946 int stepping_frame = 0;
2947 struct bp_location *loc;
2948 char *default_collect_line = NULL;
2949 struct command_line *actions, *default_collect_action = NULL;
2950 struct cleanup *old_chain;
2952 if (tracepoint_number == -1)
2954 warning (_("No current trace frame."));
2958 old_chain = make_cleanup (null_cleanup, NULL);
2959 t = get_tracepoint (tracepoint_number);
2962 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2965 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2966 tracepoint_number, traceframe_number);
2968 /* The current frame is a trap frame if the frame PC is equal
2969 to the tracepoint PC. If not, then the current frame was
2970 collected during single-stepping. */
2972 regcache = get_current_regcache ();
2974 /* If the traceframe's address matches any of the tracepoint's
2975 locations, assume it is a direct hit rather than a while-stepping
2976 frame. (FIXME this is not reliable, should record each frame's
2979 for (loc = t->base.loc; loc; loc = loc->next)
2980 if (loc->address == regcache_read_pc (regcache))
2983 actions = all_tracepoint_actions_and_cleanup (&t->base);
2985 trace_dump_actions (actions, 0, stepping_frame, from_tty);
2987 do_cleanups (old_chain);
2990 /* Encode a piece of a tracepoint's source-level definition in a form
2991 that is suitable for both protocol and saving in files. */
2992 /* This version does not do multiple encodes for long strings; it should
2993 return an offset to the next piece to encode. FIXME */
2996 encode_source_string (int tpnum, ULONGEST addr,
2997 char *srctype, char *src, char *buf, int buf_size)
2999 if (80 + strlen (srctype) > buf_size)
3000 error (_("Buffer too small for source encoding"));
3001 sprintf (buf, "%x:%s:%s:%x:%x:",
3002 tpnum, phex_nz (addr, sizeof (addr)),
3003 srctype, 0, (int) strlen (src));
3004 if (strlen (buf) + strlen (src) * 2 >= buf_size)
3005 error (_("Source string too long for buffer"));
3006 bin2hex ((gdb_byte *) src, buf + strlen (buf), 0);
3010 /* Free trace file writer. */
3013 trace_file_writer_xfree (void *arg)
3015 struct trace_file_writer *writer = arg;
3017 writer->ops->dtor (writer);
3021 /* TFILE trace writer. */
3023 struct tfile_trace_file_writer
3025 struct trace_file_writer base;
3027 /* File pointer to tfile trace file. */
3029 /* Path name of the tfile trace file. */
3033 /* This is the implementation of trace_file_write_ops method
3034 target_save. We just call the generic target
3035 target_save_trace_data to do target-side saving. */
3038 tfile_target_save (struct trace_file_writer *self,
3039 const char *filename)
3041 int err = target_save_trace_data (filename);
3046 /* This is the implementation of trace_file_write_ops method
3050 tfile_dtor (struct trace_file_writer *self)
3052 struct tfile_trace_file_writer *writer
3053 = (struct tfile_trace_file_writer *) self;
3055 xfree (writer->pathname);
3057 if (writer->fp != NULL)
3058 fclose (writer->fp);
3061 /* This is the implementation of trace_file_write_ops method
3062 start. It creates the trace file FILENAME and registers some
3066 tfile_start (struct trace_file_writer *self, const char *filename)
3068 struct tfile_trace_file_writer *writer
3069 = (struct tfile_trace_file_writer *) self;
3071 writer->pathname = tilde_expand (filename);
3072 writer->fp = gdb_fopen_cloexec (writer->pathname, "wb");
3073 if (writer->fp == NULL)
3074 error (_("Unable to open file '%s' for saving trace data (%s)"),
3075 filename, safe_strerror (errno));
3078 /* This is the implementation of trace_file_write_ops method
3079 write_header. Write the TFILE header. */
3082 tfile_write_header (struct trace_file_writer *self)
3084 struct tfile_trace_file_writer *writer
3085 = (struct tfile_trace_file_writer *) self;
3088 /* Write a file header, with a high-bit-set char to indicate a
3089 binary file, plus a hint as what this file is, and a version
3090 number in case of future needs. */
3091 written = fwrite ("\x7fTRACE0\n", 8, 1, writer->fp);
3093 perror_with_name (writer->pathname);
3096 /* This is the implementation of trace_file_write_ops method
3097 write_regblock_type. Write the size of register block. */
3100 tfile_write_regblock_type (struct trace_file_writer *self, int size)
3102 struct tfile_trace_file_writer *writer
3103 = (struct tfile_trace_file_writer *) self;
3105 fprintf (writer->fp, "R %x\n", size);
3108 /* This is the implementation of trace_file_write_ops method
3112 tfile_write_status (struct trace_file_writer *self,
3113 struct trace_status *ts)
3115 struct tfile_trace_file_writer *writer
3116 = (struct tfile_trace_file_writer *) self;
3118 fprintf (writer->fp, "status %c;%s",
3119 (ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
3120 if (ts->stop_reason == tracepoint_error
3121 || ts->stop_reason == tstop_command)
3123 char *buf = (char *) alloca (strlen (ts->stop_desc) * 2 + 1);
3125 bin2hex ((gdb_byte *) ts->stop_desc, buf, 0);
3126 fprintf (writer->fp, ":%s", buf);
3128 fprintf (writer->fp, ":%x", ts->stopping_tracepoint);
3129 if (ts->traceframe_count >= 0)
3130 fprintf (writer->fp, ";tframes:%x", ts->traceframe_count);
3131 if (ts->traceframes_created >= 0)
3132 fprintf (writer->fp, ";tcreated:%x", ts->traceframes_created);
3133 if (ts->buffer_free >= 0)
3134 fprintf (writer->fp, ";tfree:%x", ts->buffer_free);
3135 if (ts->buffer_size >= 0)
3136 fprintf (writer->fp, ";tsize:%x", ts->buffer_size);
3137 if (ts->disconnected_tracing)
3138 fprintf (writer->fp, ";disconn:%x", ts->disconnected_tracing);
3139 if (ts->circular_buffer)
3140 fprintf (writer->fp, ";circular:%x", ts->circular_buffer);
3141 if (ts->notes != NULL)
3143 char *buf = (char *) alloca (strlen (ts->notes) * 2 + 1);
3145 bin2hex ((gdb_byte *) ts->notes, buf, 0);
3146 fprintf (writer->fp, ";notes:%s", buf);
3148 if (ts->user_name != NULL)
3150 char *buf = (char *) alloca (strlen (ts->user_name) * 2 + 1);
3152 bin2hex ((gdb_byte *) ts->user_name, buf, 0);
3153 fprintf (writer->fp, ";username:%s", buf);
3155 fprintf (writer->fp, "\n");
3158 /* This is the implementation of trace_file_write_ops method
3159 write_uploaded_tsv. */
3162 tfile_write_uploaded_tsv (struct trace_file_writer *self,
3163 struct uploaded_tsv *utsv)
3166 struct tfile_trace_file_writer *writer
3167 = (struct tfile_trace_file_writer *) self;
3171 buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
3172 bin2hex ((gdb_byte *) (utsv->name), buf, 0);
3175 fprintf (writer->fp, "tsv %x:%s:%x:%s\n",
3176 utsv->number, phex_nz (utsv->initial_value, 8),
3177 utsv->builtin, buf);
3183 #define MAX_TRACE_UPLOAD 2000
3185 /* This is the implementation of trace_file_write_ops method
3186 write_uploaded_tp. */
3189 tfile_write_uploaded_tp (struct trace_file_writer *self,
3190 struct uploaded_tp *utp)
3192 struct tfile_trace_file_writer *writer
3193 = (struct tfile_trace_file_writer *) self;
3196 char buf[MAX_TRACE_UPLOAD];
3198 fprintf (writer->fp, "tp T%x:%s:%c:%x:%x",
3199 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
3200 (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
3201 if (utp->type == bp_fast_tracepoint)
3202 fprintf (writer->fp, ":F%x", utp->orig_size);
3204 fprintf (writer->fp,
3205 ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
3207 fprintf (writer->fp, "\n");
3208 for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
3209 fprintf (writer->fp, "tp A%x:%s:%s\n",
3210 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
3211 for (a = 0; VEC_iterate (char_ptr, utp->step_actions, a, act); ++a)
3212 fprintf (writer->fp, "tp S%x:%s:%s\n",
3213 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
3216 encode_source_string (utp->number, utp->addr,
3217 "at", utp->at_string, buf, MAX_TRACE_UPLOAD);
3218 fprintf (writer->fp, "tp Z%s\n", buf);
3220 if (utp->cond_string)
3222 encode_source_string (utp->number, utp->addr,
3223 "cond", utp->cond_string,
3224 buf, MAX_TRACE_UPLOAD);
3225 fprintf (writer->fp, "tp Z%s\n", buf);
3227 for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
3229 encode_source_string (utp->number, utp->addr, "cmd", act,
3230 buf, MAX_TRACE_UPLOAD);
3231 fprintf (writer->fp, "tp Z%s\n", buf);
3233 fprintf (writer->fp, "tp V%x:%s:%x:%s\n",
3234 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
3236 phex_nz (utp->traceframe_usage,
3237 sizeof (utp->traceframe_usage)));
3240 /* This is the implementation of trace_file_write_ops method
3241 write_definition_end. */
3244 tfile_write_definition_end (struct trace_file_writer *self)
3246 struct tfile_trace_file_writer *writer
3247 = (struct tfile_trace_file_writer *) self;
3249 fprintf (writer->fp, "\n");
3252 /* This is the implementation of trace_file_write_ops method
3256 tfile_write_raw_data (struct trace_file_writer *self, gdb_byte *buf,
3259 struct tfile_trace_file_writer *writer
3260 = (struct tfile_trace_file_writer *) self;
3262 if (fwrite (buf, len, 1, writer->fp) < 1)
3263 perror_with_name (writer->pathname);
3266 /* This is the implementation of trace_file_write_ops method
3270 tfile_end (struct trace_file_writer *self)
3272 struct tfile_trace_file_writer *writer
3273 = (struct tfile_trace_file_writer *) self;
3274 uint32_t gotten = 0;
3276 /* Mark the end of trace data. */
3277 if (fwrite (&gotten, 4, 1, writer->fp) < 1)
3278 perror_with_name (writer->pathname);
3281 /* Operations to write trace buffers into TFILE format. */
3283 static const struct trace_file_write_ops tfile_write_ops =
3289 tfile_write_regblock_type,
3291 tfile_write_uploaded_tsv,
3292 tfile_write_uploaded_tp,
3293 tfile_write_definition_end,
3294 tfile_write_raw_data,
3299 /* Helper macros. */
3301 #define TRACE_WRITE_R_BLOCK(writer, buf, size) \
3302 writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
3303 #define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size) \
3304 writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
3306 #define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size) \
3307 writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
3309 #define TRACE_WRITE_V_BLOCK(writer, num, val) \
3310 writer->ops->frame_ops->write_v_block ((writer), (num), (val))
3312 /* Save tracepoint data to file named FILENAME through WRITER. WRITER
3313 determines the trace file format. If TARGET_DOES_SAVE is non-zero,
3314 the save is performed on the target, otherwise GDB obtains all trace
3315 data and saves it locally. */
3318 trace_save (const char *filename, struct trace_file_writer *writer,
3319 int target_does_save)
3321 struct trace_status *ts = current_trace_status ();
3323 struct uploaded_tp *uploaded_tps = NULL, *utp;
3324 struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
3326 ULONGEST offset = 0;
3327 gdb_byte buf[MAX_TRACE_UPLOAD];
3328 #define MAX_TRACE_UPLOAD 2000
3330 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
3332 /* If the target is to save the data to a file on its own, then just
3333 send the command and be done with it. */
3334 if (target_does_save)
3336 if (!writer->ops->target_save (writer, filename))
3337 error (_("Target failed to save trace data to '%s'."),
3342 /* Get the trace status first before opening the file, so if the
3343 target is losing, we can get out without touching files. */
3344 status = target_get_trace_status (ts);
3346 writer->ops->start (writer, filename);
3348 writer->ops->write_header (writer);
3350 /* Write descriptive info. */
3352 /* Write out the size of a register block. */
3353 writer->ops->write_regblock_type (writer, trace_regblock_size);
3355 /* Write out status of the tracing run (aka "tstatus" info). */
3356 writer->ops->write_status (writer, ts);
3358 /* Note that we want to upload tracepoints and save those, rather
3359 than simply writing out the local ones, because the user may have
3360 changed tracepoints in GDB in preparation for a future tracing
3361 run, or maybe just mass-deleted all types of breakpoints as part
3362 of cleaning up. So as not to contaminate the session, leave the
3363 data in its uploaded form, don't make into real tracepoints. */
3365 /* Get trace state variables first, they may be checked when parsing
3366 uploaded commands. */
3368 target_upload_trace_state_variables (&uploaded_tsvs);
3370 for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
3371 writer->ops->write_uploaded_tsv (writer, utsv);
3373 free_uploaded_tsvs (&uploaded_tsvs);
3375 target_upload_tracepoints (&uploaded_tps);
3377 for (utp = uploaded_tps; utp; utp = utp->next)
3378 target_get_tracepoint_status (NULL, utp);
3380 for (utp = uploaded_tps; utp; utp = utp->next)
3381 writer->ops->write_uploaded_tp (writer, utp);
3383 free_uploaded_tps (&uploaded_tps);
3385 /* Mark the end of the definition section. */
3386 writer->ops->write_definition_end (writer);
3388 /* Get and write the trace data proper. */
3393 /* The writer supports writing the contents of trace buffer
3394 directly to trace file. Don't parse the contents of trace
3396 if (writer->ops->write_trace_buffer != NULL)
3398 /* We ask for big blocks, in the hopes of efficiency, but
3399 will take less if the target has packet size limitations
3401 gotten = target_get_raw_trace_data (buf, offset,
3404 error (_("Failure to get requested trace buffer data"));
3405 /* No more data is forthcoming, we're done. */
3409 writer->ops->write_trace_buffer (writer, buf, gotten);
3417 /* Parse the trace buffers according to how data are stored
3418 in trace buffer in GDBserver. */
3420 gotten = target_get_raw_trace_data (buf, offset, 6);
3425 /* Read the first six bytes in, which is the tracepoint
3426 number and trace frame size. */
3428 extract_unsigned_integer (&buf[0], 2, byte_order);
3430 tf_size = (uint32_t)
3431 extract_unsigned_integer (&buf[2], 4, byte_order);
3433 writer->ops->frame_ops->start (writer, tp_num);
3442 for (block = 0; block < tf_size; )
3444 gdb_byte block_type;
3446 /* We'll fetch one block each time, in order to
3447 handle the extremely large 'M' block. We first
3448 fetch one byte to get the type of the block. */
3449 gotten = target_get_raw_trace_data (buf, offset, 1);
3451 error (_("Failure to get requested trace buffer data"));
3457 block_type = buf[0];
3462 = target_get_raw_trace_data (buf, offset,
3463 trace_regblock_size);
3464 if (gotten < trace_regblock_size)
3465 error (_("Failure to get requested trace"
3468 TRACE_WRITE_R_BLOCK (writer, buf,
3469 trace_regblock_size);
3473 unsigned short mlen;
3478 t = target_get_raw_trace_data (buf,offset, 10);
3480 error (_("Failure to get requested trace"
3488 extract_unsigned_integer (buf, 8,
3490 mlen = (unsigned short)
3491 extract_unsigned_integer (&buf[8], 2,
3494 TRACE_WRITE_M_BLOCK_HEADER (writer, addr,
3497 /* The memory contents in 'M' block may be
3498 very large. Fetch the data from the target
3499 and write them into file one by one. */
3500 for (j = 0; j < mlen; )
3502 unsigned int read_length;
3504 if (mlen - j > MAX_TRACE_UPLOAD)
3505 read_length = MAX_TRACE_UPLOAD;
3507 read_length = mlen - j;
3509 t = target_get_raw_trace_data (buf,
3512 if (t < read_length)
3513 error (_("Failure to get requested"
3514 " trace buffer data"));
3516 TRACE_WRITE_M_BLOCK_MEMORY (writer, buf,
3520 gotten += read_length;
3531 = target_get_raw_trace_data (buf, offset,
3534 error (_("Failure to get requested"
3535 " trace buffer data"));
3537 vnum = (int) extract_signed_integer (buf,
3541 = extract_signed_integer (&buf[4], 8,
3544 TRACE_WRITE_V_BLOCK (writer, vnum, val);
3548 error (_("Unknown block type '%c' (0x%x) in"
3550 block_type, block_type);
3560 writer->ops->frame_ops->end (writer);
3564 writer->ops->end (writer);
3567 /* Return a trace writer for TFILE format. */
3569 static struct trace_file_writer *
3570 tfile_trace_file_writer_new (void)
3572 struct tfile_trace_file_writer *writer
3573 = xmalloc (sizeof (struct tfile_trace_file_writer));
3575 writer->base.ops = &tfile_write_ops;
3577 writer->pathname = NULL;
3579 return (struct trace_file_writer *) writer;
3583 trace_save_command (char *args, int from_tty)
3585 int target_does_save = 0;
3587 char *filename = NULL;
3588 struct cleanup *back_to;
3589 int generate_ctf = 0;
3590 struct trace_file_writer *writer = NULL;
3593 error_no_arg (_("file in which to save trace data"));
3595 argv = gdb_buildargv (args);
3596 back_to = make_cleanup_freeargv (argv);
3598 for (; *argv; ++argv)
3600 if (strcmp (*argv, "-r") == 0)
3601 target_does_save = 1;
3602 if (strcmp (*argv, "-ctf") == 0)
3604 else if (**argv == '-')
3605 error (_("unknown option `%s'"), *argv);
3611 error_no_arg (_("file in which to save trace data"));
3614 writer = ctf_trace_file_writer_new ();
3616 writer = tfile_trace_file_writer_new ();
3618 make_cleanup (trace_file_writer_xfree, writer);
3620 trace_save (filename, writer, target_does_save);
3623 printf_filtered (_("Trace data saved to %s '%s'.\n"),
3624 generate_ctf ? "directory" : "file", filename);
3626 do_cleanups (back_to);
3629 /* Save the trace data to file FILENAME of tfile format. */
3632 trace_save_tfile (const char *filename, int target_does_save)
3634 struct trace_file_writer *writer;
3635 struct cleanup *back_to;
3637 writer = tfile_trace_file_writer_new ();
3638 back_to = make_cleanup (trace_file_writer_xfree, writer);
3639 trace_save (filename, writer, target_does_save);
3640 do_cleanups (back_to);
3643 /* Save the trace data to dir DIRNAME of ctf format. */
3646 trace_save_ctf (const char *dirname, int target_does_save)
3648 struct trace_file_writer *writer;
3649 struct cleanup *back_to;
3651 writer = ctf_trace_file_writer_new ();
3652 back_to = make_cleanup (trace_file_writer_xfree, writer);
3654 trace_save (dirname, writer, target_does_save);
3655 do_cleanups (back_to);
3658 /* Tell the target what to do with an ongoing tracing run if GDB
3659 disconnects for some reason. */
3662 set_disconnected_tracing (char *args, int from_tty,
3663 struct cmd_list_element *c)
3665 target_set_disconnected_tracing (disconnected_tracing);
3669 set_circular_trace_buffer (char *args, int from_tty,
3670 struct cmd_list_element *c)
3672 target_set_circular_trace_buffer (circular_trace_buffer);
3676 set_trace_buffer_size (char *args, int from_tty,
3677 struct cmd_list_element *c)
3679 target_set_trace_buffer_size (trace_buffer_size);
3683 set_trace_user (char *args, int from_tty,
3684 struct cmd_list_element *c)
3688 ret = target_set_trace_notes (trace_user, NULL, NULL);
3691 warning (_("Target does not support trace notes, user ignored"));
3695 set_trace_notes (char *args, int from_tty,
3696 struct cmd_list_element *c)
3700 ret = target_set_trace_notes (NULL, trace_notes, NULL);
3703 warning (_("Target does not support trace notes, note ignored"));
3707 set_trace_stop_notes (char *args, int from_tty,
3708 struct cmd_list_element *c)
3712 ret = target_set_trace_notes (NULL, NULL, trace_stop_notes);
3715 warning (_("Target does not support trace notes, stop note ignored"));
3718 /* Convert the memory pointed to by mem into hex, placing result in buf.
3719 * Return a pointer to the last char put in buf (null)
3720 * "stolen" from sparc-stub.c
3723 static const char hexchars[] = "0123456789abcdef";
3726 mem2hex (gdb_byte *mem, char *buf, int count)
3734 *buf++ = hexchars[ch >> 4];
3735 *buf++ = hexchars[ch & 0xf];
3744 get_traceframe_number (void)
3746 return traceframe_number;
3750 get_tracepoint_number (void)
3752 return tracepoint_number;
3755 /* Make the traceframe NUM be the current trace frame. Does nothing
3756 if NUM is already current. */
3759 set_current_traceframe (int num)
3763 if (traceframe_number == num)
3765 /* Nothing to do. */
3769 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
3772 warning (_("could not change traceframe"));
3774 set_traceframe_num (newnum);
3776 /* Changing the traceframe changes our view of registers and of the
3778 registers_changed ();
3780 clear_traceframe_info ();
3783 /* Make the traceframe NUM be the current trace frame, and do nothing
3787 set_traceframe_number (int num)
3789 traceframe_number = num;
3792 /* A cleanup used when switching away and back from tfind mode. */
3794 struct current_traceframe_cleanup
3796 /* The traceframe we were inspecting. */
3797 int traceframe_number;
3801 do_restore_current_traceframe_cleanup (void *arg)
3803 struct current_traceframe_cleanup *old = arg;
3805 set_current_traceframe (old->traceframe_number);
3809 restore_current_traceframe_cleanup_dtor (void *arg)
3811 struct current_traceframe_cleanup *old = arg;
3817 make_cleanup_restore_current_traceframe (void)
3819 struct current_traceframe_cleanup *old;
3821 old = xmalloc (sizeof (struct current_traceframe_cleanup));
3822 old->traceframe_number = traceframe_number;
3824 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
3825 restore_current_traceframe_cleanup_dtor);
3829 make_cleanup_restore_traceframe_number (void)
3831 return make_cleanup_restore_integer (&traceframe_number);
3834 /* Given a number and address, return an uploaded tracepoint with that
3835 number, creating if necessary. */
3837 struct uploaded_tp *
3838 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
3840 struct uploaded_tp *utp;
3842 for (utp = *utpp; utp; utp = utp->next)
3843 if (utp->number == num && utp->addr == addr)
3845 utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
3846 memset (utp, 0, sizeof (struct uploaded_tp));
3849 utp->actions = NULL;
3850 utp->step_actions = NULL;
3851 utp->cmd_strings = NULL;
3858 free_uploaded_tps (struct uploaded_tp **utpp)
3860 struct uploaded_tp *next_one;
3864 next_one = (*utpp)->next;
3870 /* Given a number and address, return an uploaded tracepoint with that
3871 number, creating if necessary. */
3873 struct uploaded_tsv *
3874 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
3876 struct uploaded_tsv *utsv;
3878 for (utsv = *utsvp; utsv; utsv = utsv->next)
3879 if (utsv->number == num)
3881 utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
3882 memset (utsv, 0, sizeof (struct uploaded_tsv));
3884 utsv->next = *utsvp;
3890 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3892 struct uploaded_tsv *next_one;
3896 next_one = (*utsvp)->next;
3902 /* FIXME this function is heuristic and will miss the cases where the
3903 conditional is semantically identical but differs in whitespace,
3904 such as "x == 0" vs "x==0". */
3907 cond_string_is_same (char *str1, char *str2)
3909 if (str1 == NULL || str2 == NULL)
3910 return (str1 == str2);
3912 return (strcmp (str1, str2) == 0);
3915 /* Look for an existing tracepoint that seems similar enough to the
3916 uploaded one. Enablement isn't compared, because the user can
3917 toggle that freely, and may have done so in anticipation of the
3918 next trace run. Return the location of matched tracepoint. */
3920 static struct bp_location *
3921 find_matching_tracepoint_location (struct uploaded_tp *utp)
3923 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
3925 struct breakpoint *b;
3926 struct bp_location *loc;
3928 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
3930 struct tracepoint *t = (struct tracepoint *) b;
3932 if (b->type == utp->type
3933 && t->step_count == utp->step
3934 && t->pass_count == utp->pass
3935 && cond_string_is_same (t->base.cond_string, utp->cond_string)
3936 /* FIXME also test actions. */
3939 /* Scan the locations for an address match. */
3940 for (loc = b->loc; loc; loc = loc->next)
3942 if (loc->address == utp->addr)
3950 /* Given a list of tracepoints uploaded from a target, attempt to
3951 match them up with existing tracepoints, and create new ones if not
3955 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3957 struct uploaded_tp *utp;
3958 /* A set of tracepoints which are modified. */
3959 VEC(breakpoint_p) *modified_tp = NULL;
3961 struct breakpoint *b;
3963 /* Look for GDB tracepoints that match up with our uploaded versions. */
3964 for (utp = *uploaded_tps; utp; utp = utp->next)
3966 struct bp_location *loc;
3967 struct tracepoint *t;
3969 loc = find_matching_tracepoint_location (utp);
3974 /* Mark this location as already inserted. */
3976 t = (struct tracepoint *) loc->owner;
3977 printf_filtered (_("Assuming tracepoint %d is same "
3978 "as target's tracepoint %d at %s.\n"),
3979 loc->owner->number, utp->number,
3980 paddress (loc->gdbarch, utp->addr));
3982 /* The tracepoint LOC->owner was modified (the location LOC
3983 was marked as inserted in the target). Save it in
3984 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3985 observers will be notified later once for each tracepoint
3986 saved in MODIFIED_TP. */
3988 VEC_iterate (breakpoint_p, modified_tp, ix, b);
3990 if (b == loc->owner)
3996 VEC_safe_push (breakpoint_p, modified_tp, loc->owner);
4000 t = create_tracepoint_from_upload (utp);
4002 printf_filtered (_("Created tracepoint %d for "
4003 "target's tracepoint %d at %s.\n"),
4004 t->base.number, utp->number,
4005 paddress (get_current_arch (), utp->addr));
4007 printf_filtered (_("Failed to create tracepoint for target's "
4008 "tracepoint %d at %s, skipping it.\n"),
4010 paddress (get_current_arch (), utp->addr));
4012 /* Whether found or created, record the number used by the
4013 target, to help with mapping target tracepoints back to their
4014 counterparts here. */
4016 t->number_on_target = utp->number;
4019 /* Notify 'breakpoint-modified' observer that at least one of B's
4020 locations was changed. */
4021 for (ix = 0; VEC_iterate (breakpoint_p, modified_tp, ix, b); ix++)
4022 observer_notify_breakpoint_modified (b);
4024 VEC_free (breakpoint_p, modified_tp);
4025 free_uploaded_tps (uploaded_tps);
4028 /* Trace state variables don't have much to identify them beyond their
4029 name, so just use that to detect matches. */
4031 static struct trace_state_variable *
4032 find_matching_tsv (struct uploaded_tsv *utsv)
4037 return find_trace_state_variable (utsv->name);
4040 static struct trace_state_variable *
4041 create_tsv_from_upload (struct uploaded_tsv *utsv)
4043 const char *namebase;
4046 struct trace_state_variable *tsv;
4047 struct cleanup *old_chain;
4051 namebase = utsv->name;
4052 buf = xstrprintf ("%s", namebase);
4057 buf = xstrprintf ("%s_%d", namebase, try_num++);
4060 /* Fish for a name that is not in use. */
4061 /* (should check against all internal vars?) */
4062 while (find_trace_state_variable (buf))
4065 buf = xstrprintf ("%s_%d", namebase, try_num++);
4068 old_chain = make_cleanup (xfree, buf);
4070 /* We have an available name, create the variable. */
4071 tsv = create_trace_state_variable (buf);
4072 tsv->initial_value = utsv->initial_value;
4073 tsv->builtin = utsv->builtin;
4075 observer_notify_tsv_created (tsv);
4077 do_cleanups (old_chain);
4082 /* Given a list of uploaded trace state variables, try to match them
4083 up with existing variables, or create additional ones. */
4086 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
4089 struct uploaded_tsv *utsv;
4090 struct trace_state_variable *tsv;
4093 /* Most likely some numbers will have to be reassigned as part of
4094 the merge, so clear them all in anticipation. */
4095 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
4098 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
4100 tsv = find_matching_tsv (utsv);
4104 printf_filtered (_("Assuming trace state variable $%s "
4105 "is same as target's variable %d.\n"),
4106 tsv->name, utsv->number);
4110 tsv = create_tsv_from_upload (utsv);
4112 printf_filtered (_("Created trace state variable "
4113 "$%s for target's variable %d.\n"),
4114 tsv->name, utsv->number);
4116 /* Give precedence to numberings that come from the target. */
4118 tsv->number = utsv->number;
4121 /* Renumber everything that didn't get a target-assigned number. */
4123 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
4124 if (tsv->number > highest)
4125 highest = tsv->number;
4128 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
4129 if (tsv->number == 0)
4130 tsv->number = highest++;
4132 free_uploaded_tsvs (uploaded_tsvs);
4135 /* target tfile command */
4137 static struct target_ops tfile_ops;
4139 /* Fill in tfile_ops with its defined operations and properties. */
4141 #define TRACE_HEADER_SIZE 8
4143 static char *trace_filename;
4144 static int trace_fd = -1;
4145 static off_t trace_frames_offset;
4146 static off_t cur_offset;
4147 static int cur_data_size;
4148 int trace_regblock_size;
4150 static void tfile_interp_line (char *line,
4151 struct uploaded_tp **utpp,
4152 struct uploaded_tsv **utsvp);
4154 /* Read SIZE bytes into READBUF from the trace frame, starting at
4155 TRACE_FD's current position. Note that this call `read'
4156 underneath, hence it advances the file's seek position. Throws an
4157 error if the `read' syscall fails, or less than SIZE bytes are
4161 tfile_read (gdb_byte *readbuf, int size)
4165 gotten = read (trace_fd, readbuf, size);
4167 perror_with_name (trace_filename);
4168 else if (gotten < size)
4169 error (_("Premature end of file while reading trace file"));
4173 tfile_open (char *filename, int from_tty)
4175 volatile struct gdb_exception ex;
4177 struct cleanup *old_chain;
4180 char header[TRACE_HEADER_SIZE];
4181 char linebuf[1000]; /* Should be max remote packet size or so. */
4184 struct trace_status *ts;
4185 struct uploaded_tp *uploaded_tps = NULL;
4186 struct uploaded_tsv *uploaded_tsvs = NULL;
4188 target_preopen (from_tty);
4190 error (_("No trace file specified."));
4192 filename = tilde_expand (filename);
4193 if (!IS_ABSOLUTE_PATH(filename))
4195 temp = concat (current_directory, "/", filename, (char *) NULL);
4200 old_chain = make_cleanup (xfree, filename);
4202 flags = O_BINARY | O_LARGEFILE;
4204 scratch_chan = gdb_open_cloexec (filename, flags, 0);
4205 if (scratch_chan < 0)
4206 perror_with_name (filename);
4208 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
4210 discard_cleanups (old_chain); /* Don't free filename any more. */
4211 unpush_target (&tfile_ops);
4213 trace_filename = xstrdup (filename);
4214 trace_fd = scratch_chan;
4217 /* Read the file header and test for validity. */
4218 tfile_read ((gdb_byte *) &header, TRACE_HEADER_SIZE);
4220 bytes += TRACE_HEADER_SIZE;
4221 if (!(header[0] == 0x7f
4222 && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
4223 error (_("File is not a valid trace file."));
4225 push_target (&tfile_ops);
4227 trace_regblock_size = 0;
4228 ts = current_trace_status ();
4229 /* We know we're working with a file. Record its name. */
4230 ts->filename = trace_filename;
4231 /* Set defaults in case there is no status line. */
4232 ts->running_known = 0;
4233 ts->stop_reason = trace_stop_reason_unknown;
4234 ts->traceframe_count = -1;
4235 ts->buffer_free = 0;
4236 ts->disconnected_tracing = 0;
4237 ts->circular_buffer = 0;
4239 TRY_CATCH (ex, RETURN_MASK_ALL)
4241 /* Read through a section of newline-terminated lines that
4242 define things like tracepoints. */
4246 tfile_read (&byte, 1);
4251 /* Empty line marks end of the definition section. */
4256 tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
4259 linebuf[i++] = byte;
4261 error (_("Excessively long lines in trace file"));
4264 /* Record the starting offset of the binary trace data. */
4265 trace_frames_offset = bytes;
4267 /* If we don't have a blocksize, we can't interpret the
4269 if (trace_regblock_size == 0)
4270 error (_("No register block size recorded in trace file"));
4274 /* Pop the partially set up target. */
4276 throw_exception (ex);
4279 if (ts->traceframe_count <= 0)
4280 warning (_("No traceframes present in this file."));
4282 /* Add the file's tracepoints and variables into the current mix. */
4284 /* Get trace state variables first, they may be checked when parsing
4285 uploaded commands. */
4286 merge_uploaded_trace_state_variables (&uploaded_tsvs);
4288 merge_uploaded_tracepoints (&uploaded_tps);
4291 /* Interpret the given line from the definitions part of the trace
4295 tfile_interp_line (char *line, struct uploaded_tp **utpp,
4296 struct uploaded_tsv **utsvp)
4300 if (strncmp (p, "R ", strlen ("R ")) == 0)
4303 trace_regblock_size = strtol (p, &p, 16);
4305 else if (strncmp (p, "status ", strlen ("status ")) == 0)
4307 p += strlen ("status ");
4308 parse_trace_status (p, current_trace_status ());
4310 else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
4312 p += strlen ("tp ");
4313 parse_tracepoint_definition (p, utpp);
4315 else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
4317 p += strlen ("tsv ");
4318 parse_tsv_definition (p, utsvp);
4321 warning (_("Ignoring trace file definition \"%s\""), line);
4324 /* Parse the part of trace status syntax that is shared between
4325 the remote protocol and the trace file reader. */
4328 parse_trace_status (char *line, struct trace_status *ts)
4330 char *p = line, *p1, *p2, *p3, *p_temp;
4334 ts->running_known = 1;
4335 ts->running = (*p++ == '1');
4336 ts->stop_reason = trace_stop_reason_unknown;
4337 xfree (ts->stop_desc);
4338 ts->stop_desc = NULL;
4339 ts->traceframe_count = -1;
4340 ts->traceframes_created = -1;
4341 ts->buffer_free = -1;
4342 ts->buffer_size = -1;
4343 ts->disconnected_tracing = 0;
4344 ts->circular_buffer = 0;
4345 xfree (ts->user_name);
4346 ts->user_name = NULL;
4349 ts->start_time = ts->stop_time = 0;
4353 p1 = strchr (p, ':');
4355 error (_("Malformed trace status, at %s\n\
4356 Status line: '%s'\n"), p, line);
4357 p3 = strchr (p, ';');
4359 p3 = p + strlen (p);
4360 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
4362 p = unpack_varlen_hex (++p1, &val);
4363 ts->stop_reason = trace_buffer_full;
4365 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
4367 p = unpack_varlen_hex (++p1, &val);
4368 ts->stop_reason = trace_never_run;
4370 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
4373 p = unpack_varlen_hex (++p1, &val);
4374 ts->stop_reason = tracepoint_passcount;
4375 ts->stopping_tracepoint = val;
4377 else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
4379 p2 = strchr (++p1, ':');
4387 ts->stop_desc = xmalloc (strlen (line));
4388 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
4389 ts->stop_desc[end] = '\0';
4392 ts->stop_desc = xstrdup ("");
4394 p = unpack_varlen_hex (++p2, &val);
4395 ts->stop_reason = tstop_command;
4397 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
4399 p = unpack_varlen_hex (++p1, &val);
4400 ts->stop_reason = trace_disconnected;
4402 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
4404 p2 = strchr (++p1, ':');
4407 ts->stop_desc = xmalloc ((p2 - p1) / 2 + 1);
4408 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
4409 ts->stop_desc[end] = '\0';
4412 ts->stop_desc = xstrdup ("");
4414 p = unpack_varlen_hex (++p2, &val);
4415 ts->stopping_tracepoint = val;
4416 ts->stop_reason = tracepoint_error;
4418 else if (strncmp (p, "tframes", p1 - p) == 0)
4420 p = unpack_varlen_hex (++p1, &val);
4421 ts->traceframe_count = val;
4423 else if (strncmp (p, "tcreated", p1 - p) == 0)
4425 p = unpack_varlen_hex (++p1, &val);
4426 ts->traceframes_created = val;
4428 else if (strncmp (p, "tfree", p1 - p) == 0)
4430 p = unpack_varlen_hex (++p1, &val);
4431 ts->buffer_free = val;
4433 else if (strncmp (p, "tsize", p1 - p) == 0)
4435 p = unpack_varlen_hex (++p1, &val);
4436 ts->buffer_size = val;
4438 else if (strncmp (p, "disconn", p1 - p) == 0)
4440 p = unpack_varlen_hex (++p1, &val);
4441 ts->disconnected_tracing = val;
4443 else if (strncmp (p, "circular", p1 - p) == 0)
4445 p = unpack_varlen_hex (++p1, &val);
4446 ts->circular_buffer = val;
4448 else if (strncmp (p, "starttime", p1 - p) == 0)
4450 p = unpack_varlen_hex (++p1, &val);
4451 ts->start_time = val;
4453 else if (strncmp (p, "stoptime", p1 - p) == 0)
4455 p = unpack_varlen_hex (++p1, &val);
4456 ts->stop_time = val;
4458 else if (strncmp (p, "username", p1 - p) == 0)
4461 ts->user_name = xmalloc (strlen (p) / 2);
4462 end = hex2bin (p1, (gdb_byte *) ts->user_name, (p3 - p1) / 2);
4463 ts->user_name[end] = '\0';
4466 else if (strncmp (p, "notes", p1 - p) == 0)
4469 ts->notes = xmalloc (strlen (p) / 2);
4470 end = hex2bin (p1, (gdb_byte *) ts->notes, (p3 - p1) / 2);
4471 ts->notes[end] = '\0';
4476 /* Silently skip unknown optional info. */
4477 p_temp = strchr (p1 + 1, ';');
4481 /* Must be at the end. */
4488 parse_tracepoint_status (char *p, struct breakpoint *bp,
4489 struct uploaded_tp *utp)
4492 struct tracepoint *tp = (struct tracepoint *) bp;
4494 p = unpack_varlen_hex (p, &uval);
4496 tp->base.hit_count += uval;
4498 utp->hit_count += uval;
4499 p = unpack_varlen_hex (p + 1, &uval);
4501 tp->traceframe_usage += uval;
4503 utp->traceframe_usage += uval;
4504 /* Ignore any extra, allowing for future extensions. */
4507 /* Given a line of text defining a part of a tracepoint, parse it into
4508 an "uploaded tracepoint". */
4511 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
4515 ULONGEST num, addr, step, pass, orig_size, xlen, start;
4518 char *cond, *srctype, *buf;
4519 struct uploaded_tp *utp = NULL;
4522 /* Both tracepoint and action definitions start with the same number
4523 and address sequence. */
4525 p = unpack_varlen_hex (p, &num);
4526 p++; /* skip a colon */
4527 p = unpack_varlen_hex (p, &addr);
4528 p++; /* skip a colon */
4531 enabled = (*p++ == 'E');
4532 p++; /* skip a colon */
4533 p = unpack_varlen_hex (p, &step);
4534 p++; /* skip a colon */
4535 p = unpack_varlen_hex (p, &pass);
4536 type = bp_tracepoint;
4538 /* Thumb through optional fields. */
4541 p++; /* skip a colon */
4544 type = bp_fast_tracepoint;
4546 p = unpack_varlen_hex (p, &orig_size);
4550 type = bp_static_tracepoint;
4556 p = unpack_varlen_hex (p, &xlen);
4557 p++; /* skip a comma */
4558 cond = (char *) xmalloc (2 * xlen + 1);
4559 strncpy (cond, p, 2 * xlen);
4560 cond[2 * xlen] = '\0';
4564 warning (_("Unrecognized char '%c' in tracepoint "
4565 "definition, skipping rest"), *p);
4567 utp = get_uploaded_tp (num, addr, utpp);
4569 utp->enabled = enabled;
4574 else if (piece == 'A')
4576 utp = get_uploaded_tp (num, addr, utpp);
4577 VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
4579 else if (piece == 'S')
4581 utp = get_uploaded_tp (num, addr, utpp);
4582 VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
4584 else if (piece == 'Z')
4586 /* Parse a chunk of source form definition. */
4587 utp = get_uploaded_tp (num, addr, utpp);
4589 p = strchr (p, ':');
4590 p++; /* skip a colon */
4591 p = unpack_varlen_hex (p, &start);
4592 p++; /* skip a colon */
4593 p = unpack_varlen_hex (p, &xlen);
4594 p++; /* skip a colon */
4596 buf = alloca (strlen (line));
4598 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
4601 if (strncmp (srctype, "at:", strlen ("at:")) == 0)
4602 utp->at_string = xstrdup (buf);
4603 else if (strncmp (srctype, "cond:", strlen ("cond:")) == 0)
4604 utp->cond_string = xstrdup (buf);
4605 else if (strncmp (srctype, "cmd:", strlen ("cmd:")) == 0)
4606 VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
4608 else if (piece == 'V')
4610 utp = get_uploaded_tp (num, addr, utpp);
4612 parse_tracepoint_status (p, NULL, utp);
4616 /* Don't error out, the target might be sending us optional
4617 info that we don't care about. */
4618 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
4622 /* Convert a textual description of a trace state variable into an
4626 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
4629 ULONGEST num, initval, builtin;
4631 struct uploaded_tsv *utsv = NULL;
4633 buf = alloca (strlen (line));
4636 p = unpack_varlen_hex (p, &num);
4637 p++; /* skip a colon */
4638 p = unpack_varlen_hex (p, &initval);
4639 p++; /* skip a colon */
4640 p = unpack_varlen_hex (p, &builtin);
4641 p++; /* skip a colon */
4642 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
4645 utsv = get_uploaded_tsv (num, utsvp);
4646 utsv->initial_value = initval;
4647 utsv->builtin = builtin;
4648 utsv->name = xstrdup (buf);
4651 /* Close the trace file and generally clean up. */
4663 xfree (trace_filename);
4664 trace_filename = NULL;
4666 trace_reset_local_state ();
4670 tfile_files_info (struct target_ops *t)
4672 printf_filtered ("\t`%s'\n", trace_filename);
4675 /* The trace status for a file is that tracing can never be run. */
4678 tfile_get_trace_status (struct trace_status *ts)
4680 /* Other bits of trace status were collected as part of opening the
4681 trace files, so nothing to do here. */
4687 tfile_get_tracepoint_status (struct breakpoint *tp, struct uploaded_tp *utp)
4689 /* Other bits of trace status were collected as part of opening the
4690 trace files, so nothing to do here. */
4693 /* Given the position of a traceframe in the file, figure out what
4694 address the frame was collected at. This would normally be the
4695 value of a collected PC register, but if not available, we
4699 tfile_get_traceframe_address (off_t tframe_offset)
4703 struct tracepoint *tp;
4704 off_t saved_offset = cur_offset;
4706 /* FIXME dig pc out of collected registers. */
4708 /* Fall back to using tracepoint address. */
4709 lseek (trace_fd, tframe_offset, SEEK_SET);
4710 tfile_read ((gdb_byte *) &tpnum, 2);
4711 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
4713 (target_gdbarch ()));
4715 tp = get_tracepoint_by_number_on_target (tpnum);
4716 /* FIXME this is a poor heuristic if multiple locations. */
4717 if (tp && tp->base.loc)
4718 addr = tp->base.loc->address;
4720 /* Restore our seek position. */
4721 cur_offset = saved_offset;
4722 lseek (trace_fd, cur_offset, SEEK_SET);
4726 /* Given a type of search and some parameters, scan the collection of
4727 traceframes in the file looking for a match. When found, return
4728 both the traceframe and tracepoint number, otherwise -1 for
4732 tfile_trace_find (enum trace_find_type type, int num,
4733 CORE_ADDR addr1, CORE_ADDR addr2, int *tpp)
4736 int tfnum = 0, found = 0;
4737 unsigned int data_size;
4738 struct tracepoint *tp;
4739 off_t offset, tframe_offset;
4749 lseek (trace_fd, trace_frames_offset, SEEK_SET);
4750 offset = trace_frames_offset;
4753 tframe_offset = offset;
4754 tfile_read ((gdb_byte *) &tpnum, 2);
4755 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
4757 (target_gdbarch ()));
4761 tfile_read ((gdb_byte *) &data_size, 4);
4762 data_size = (unsigned int) extract_unsigned_integer
4763 ((gdb_byte *) &data_size, 4,
4764 gdbarch_byte_order (target_gdbarch ()));
4767 if (type == tfind_number)
4769 /* Looking for a specific trace frame. */
4775 /* Start from the _next_ trace frame. */
4776 if (tfnum > traceframe_number)
4781 tfaddr = tfile_get_traceframe_address (tframe_offset);
4782 if (tfaddr == addr1)
4786 tp = get_tracepoint (num);
4787 if (tp && tpnum == tp->number_on_target)
4791 tfaddr = tfile_get_traceframe_address (tframe_offset);
4792 if (addr1 <= tfaddr && tfaddr <= addr2)
4796 tfaddr = tfile_get_traceframe_address (tframe_offset);
4797 if (!(addr1 <= tfaddr && tfaddr <= addr2))
4801 internal_error (__FILE__, __LINE__, _("unknown tfind type"));
4810 cur_offset = offset;
4811 cur_data_size = data_size;
4815 /* Skip past the traceframe's data. */
4816 lseek (trace_fd, data_size, SEEK_CUR);
4817 offset += data_size;
4818 /* Update our own count of traceframes. */
4821 /* Did not find what we were looking for. */
4827 /* Prototype of the callback passed to tframe_walk_blocks. */
4828 typedef int (*walk_blocks_callback_func) (char blocktype, void *data);
4830 /* Callback for traceframe_walk_blocks, used to find a given block
4831 type in a traceframe. */
4834 match_blocktype (char blocktype, void *data)
4836 char *wantedp = data;
4838 if (*wantedp == blocktype)
4844 /* Walk over all traceframe block starting at POS offset from
4845 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4846 unmodified. If CALLBACK returns true, this returns the position in
4847 the traceframe where the block is found, relative to the start of
4848 the traceframe (cur_offset). Returns -1 if no callback call
4849 returned true, indicating that all blocks have been walked. */
4852 traceframe_walk_blocks (walk_blocks_callback_func callback,
4853 int pos, void *data)
4855 /* Iterate through a traceframe's blocks, looking for a block of the
4858 lseek (trace_fd, cur_offset + pos, SEEK_SET);
4859 while (pos < cur_data_size)
4861 unsigned short mlen;
4864 tfile_read ((gdb_byte *) &block_type, 1);
4868 if ((*callback) (block_type, data))
4874 lseek (trace_fd, cur_offset + pos + trace_regblock_size, SEEK_SET);
4875 pos += trace_regblock_size;
4878 lseek (trace_fd, cur_offset + pos + 8, SEEK_SET);
4879 tfile_read ((gdb_byte *) &mlen, 2);
4880 mlen = (unsigned short)
4881 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
4883 (target_gdbarch ()));
4884 lseek (trace_fd, mlen, SEEK_CUR);
4885 pos += (8 + 2 + mlen);
4888 lseek (trace_fd, cur_offset + pos + 4 + 8, SEEK_SET);
4892 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4893 block_type, block_type);
4901 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4902 position offset of a block of type TYPE_WANTED in the current trace
4903 frame, starting at POS. Returns -1 if no such block was found. */
4906 traceframe_find_block_type (char type_wanted, int pos)
4908 return traceframe_walk_blocks (match_blocktype, pos, &type_wanted);
4911 /* Look for a block of saved registers in the traceframe, and get the
4912 requested register from it. */
4915 tfile_fetch_registers (struct target_ops *ops,
4916 struct regcache *regcache, int regno)
4918 struct gdbarch *gdbarch = get_regcache_arch (regcache);
4919 int offset, regn, regsize, pc_regno;
4922 /* An uninitialized reg size says we're not going to be
4923 successful at getting register blocks. */
4924 if (!trace_regblock_size)
4927 regs = alloca (trace_regblock_size);
4929 if (traceframe_find_block_type ('R', 0) >= 0)
4931 tfile_read (regs, trace_regblock_size);
4933 /* Assume the block is laid out in GDB register number order,
4934 each register with the size that it has in GDB. */
4936 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
4938 regsize = register_size (gdbarch, regn);
4939 /* Make sure we stay within block bounds. */
4940 if (offset + regsize >= trace_regblock_size)
4942 if (regcache_register_status (regcache, regn) == REG_UNKNOWN)
4946 regcache_raw_supply (regcache, regno, regs + offset);
4949 else if (regno == -1)
4951 regcache_raw_supply (regcache, regn, regs + offset);
4959 /* We get here if no register data has been found. Mark registers
4961 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
4962 regcache_raw_supply (regcache, regn, NULL);
4964 /* We can often usefully guess that the PC is going to be the same
4965 as the address of the tracepoint. */
4966 pc_regno = gdbarch_pc_regnum (gdbarch);
4967 if (pc_regno >= 0 && (regno == -1 || regno == pc_regno))
4969 struct tracepoint *tp = get_tracepoint (tracepoint_number);
4971 if (tp && tp->base.loc)
4973 /* But don't try to guess if tracepoint is multi-location... */
4974 if (tp->base.loc->next)
4976 warning (_("Tracepoint %d has multiple "
4977 "locations, cannot infer $pc"),
4981 /* ... or does while-stepping. */
4982 if (tp->step_count > 0)
4984 warning (_("Tracepoint %d does while-stepping, "
4985 "cannot infer $pc"),
4990 store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
4991 gdbarch_byte_order (gdbarch),
4992 tp->base.loc->address);
4993 regcache_raw_supply (regcache, pc_regno, regs);
4999 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
5000 const char *annex, gdb_byte *readbuf,
5001 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
5003 /* We're only doing regular memory for now. */
5004 if (object != TARGET_OBJECT_MEMORY)
5007 if (readbuf == NULL)
5008 error (_("tfile_xfer_partial: trace file is read-only"));
5010 if (traceframe_number != -1)
5014 /* Iterate through the traceframe's blocks, looking for
5016 while ((pos = traceframe_find_block_type ('M', pos)) >= 0)
5018 ULONGEST maddr, amt;
5019 unsigned short mlen;
5020 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
5022 tfile_read ((gdb_byte *) &maddr, 8);
5023 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
5025 tfile_read ((gdb_byte *) &mlen, 2);
5026 mlen = (unsigned short)
5027 extract_unsigned_integer ((gdb_byte *) &mlen, 2, byte_order);
5029 /* If the block includes the first part of the desired
5030 range, return as much it has; GDB will re-request the
5031 remainder, which might be in a different block of this
5033 if (maddr <= offset && offset < (maddr + mlen))
5035 amt = (maddr + mlen) - offset;
5039 if (maddr != offset)
5040 lseek (trace_fd, offset - maddr, SEEK_CUR);
5041 tfile_read (readbuf, amt);
5045 /* Skip over this block. */
5046 pos += (8 + 2 + mlen);
5050 /* It's unduly pedantic to refuse to look at the executable for
5051 read-only pieces; so do the equivalent of readonly regions aka
5053 /* FIXME account for relocation at some point. */
5060 for (s = exec_bfd->sections; s; s = s->next)
5062 if ((s->flags & SEC_LOAD) == 0
5063 || (s->flags & SEC_READONLY) == 0)
5067 size = bfd_get_section_size (s);
5068 if (vma <= offset && offset < (vma + size))
5072 amt = (vma + size) - offset;
5076 amt = bfd_get_section_contents (exec_bfd, s,
5077 readbuf, offset - vma, amt);
5083 /* Indicate failure to find the requested memory block. */
5087 /* Iterate through the blocks of a trace frame, looking for a 'V'
5088 block with a matching tsv number. */
5091 tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
5096 /* Iterate over blocks in current frame and find the last 'V'
5097 block in which tsv number is TSVNUM. In one trace frame, there
5098 may be multiple 'V' blocks created for a given trace variable,
5099 and the last matched 'V' block contains the updated value. */
5101 while ((pos = traceframe_find_block_type ('V', pos)) >= 0)
5105 tfile_read ((gdb_byte *) &vnum, 4);
5106 vnum = (int) extract_signed_integer ((gdb_byte *) &vnum, 4,
5108 (target_gdbarch ()));
5111 tfile_read ((gdb_byte *) val, 8);
5112 *val = extract_signed_integer ((gdb_byte *) val, 8,
5114 (target_gdbarch ()));
5124 tfile_has_all_memory (struct target_ops *ops)
5130 tfile_has_memory (struct target_ops *ops)
5136 tfile_has_stack (struct target_ops *ops)
5138 return traceframe_number != -1;
5142 tfile_has_registers (struct target_ops *ops)
5144 return traceframe_number != -1;
5147 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
5148 object for the tfile target's current traceframe. */
5151 build_traceframe_info (char blocktype, void *data)
5153 struct traceframe_info *info = data;
5159 struct mem_range *r;
5161 unsigned short mlen;
5163 tfile_read ((gdb_byte *) &maddr, 8);
5164 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
5166 (target_gdbarch ()));
5167 tfile_read ((gdb_byte *) &mlen, 2);
5168 mlen = (unsigned short)
5169 extract_unsigned_integer ((gdb_byte *) &mlen,
5170 2, gdbarch_byte_order
5171 (target_gdbarch ()));
5173 r = VEC_safe_push (mem_range_s, info->memory, NULL);
5186 warning (_("Unhandled trace block type (%d) '%c ' "
5187 "while building trace frame info."),
5188 blocktype, blocktype);
5195 static struct traceframe_info *
5196 tfile_traceframe_info (void)
5198 struct traceframe_info *info = XCNEW (struct traceframe_info);
5200 traceframe_walk_blocks (build_traceframe_info, 0, info);
5205 init_tfile_ops (void)
5207 tfile_ops.to_shortname = "tfile";
5208 tfile_ops.to_longname = "Local trace dump file";
5210 = "Use a trace file as a target. Specify the filename of the trace file.";
5211 tfile_ops.to_open = tfile_open;
5212 tfile_ops.to_close = tfile_close;
5213 tfile_ops.to_fetch_registers = tfile_fetch_registers;
5214 tfile_ops.to_xfer_partial = tfile_xfer_partial;
5215 tfile_ops.to_files_info = tfile_files_info;
5216 tfile_ops.to_get_trace_status = tfile_get_trace_status;
5217 tfile_ops.to_get_tracepoint_status = tfile_get_tracepoint_status;
5218 tfile_ops.to_trace_find = tfile_trace_find;
5219 tfile_ops.to_get_trace_state_variable_value
5220 = tfile_get_trace_state_variable_value;
5221 tfile_ops.to_stratum = process_stratum;
5222 tfile_ops.to_has_all_memory = tfile_has_all_memory;
5223 tfile_ops.to_has_memory = tfile_has_memory;
5224 tfile_ops.to_has_stack = tfile_has_stack;
5225 tfile_ops.to_has_registers = tfile_has_registers;
5226 tfile_ops.to_traceframe_info = tfile_traceframe_info;
5227 tfile_ops.to_magic = OPS_MAGIC;
5231 free_current_marker (void *arg)
5233 struct static_tracepoint_marker **marker_p = arg;
5235 if (*marker_p != NULL)
5237 release_static_tracepoint_marker (*marker_p);
5244 /* Given a line of text defining a static tracepoint marker, parse it
5245 into a "static tracepoint marker" object. Throws an error is
5246 parsing fails. If PP is non-null, it points to one past the end of
5247 the parsed marker definition. */
5250 parse_static_tracepoint_marker_definition (char *line, char **pp,
5251 struct static_tracepoint_marker *marker)
5258 p = unpack_varlen_hex (p, &addr);
5259 p++; /* skip a colon */
5261 marker->gdbarch = target_gdbarch ();
5262 marker->address = (CORE_ADDR) addr;
5264 endp = strchr (p, ':');
5266 error (_("bad marker definition: %s"), line);
5268 marker->str_id = xmalloc (endp - p + 1);
5269 end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
5270 marker->str_id[end] = '\0';
5273 p++; /* skip a colon */
5275 marker->extra = xmalloc (strlen (p) + 1);
5276 end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
5277 marker->extra[end] = '\0';
5283 /* Release a static tracepoint marker's contents. Note that the
5284 object itself isn't released here. There objects are usually on
5288 release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
5290 xfree (marker->str_id);
5291 marker->str_id = NULL;
5294 /* Print MARKER to gdb_stdout. */
5297 print_one_static_tracepoint_marker (int count,
5298 struct static_tracepoint_marker *marker)
5300 struct command_line *l;
5303 char wrap_indent[80];
5304 char extra_field_indent[80];
5305 struct ui_out *uiout = current_uiout;
5306 struct cleanup *bkpt_chain;
5307 VEC(breakpoint_p) *tracepoints;
5309 struct symtab_and_line sal;
5313 sal.pc = marker->address;
5315 tracepoints = static_tracepoints_here (marker->address);
5317 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "marker");
5319 /* A counter field to help readability. This is not a stable
5321 ui_out_field_int (uiout, "count", count);
5323 ui_out_field_string (uiout, "marker-id", marker->str_id);
5325 ui_out_field_fmt (uiout, "enabled", "%c",
5326 !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
5327 ui_out_spaces (uiout, 2);
5329 strcpy (wrap_indent, " ");
5331 if (gdbarch_addr_bit (marker->gdbarch) <= 32)
5332 strcat (wrap_indent, " ");
5334 strcat (wrap_indent, " ");
5336 strcpy (extra_field_indent, " ");
5338 ui_out_field_core_addr (uiout, "addr", marker->gdbarch, marker->address);
5340 sal = find_pc_line (marker->address, 0);
5341 sym = find_pc_sect_function (marker->address, NULL);
5344 ui_out_text (uiout, "in ");
5345 ui_out_field_string (uiout, "func",
5346 SYMBOL_PRINT_NAME (sym));
5347 ui_out_wrap_hint (uiout, wrap_indent);
5348 ui_out_text (uiout, " at ");
5351 ui_out_field_skip (uiout, "func");
5353 if (sal.symtab != NULL)
5355 ui_out_field_string (uiout, "file",
5356 symtab_to_filename_for_display (sal.symtab));
5357 ui_out_text (uiout, ":");
5359 if (ui_out_is_mi_like_p (uiout))
5361 const char *fullname = symtab_to_fullname (sal.symtab);
5363 ui_out_field_string (uiout, "fullname", fullname);
5366 ui_out_field_skip (uiout, "fullname");
5368 ui_out_field_int (uiout, "line", sal.line);
5372 ui_out_field_skip (uiout, "fullname");
5373 ui_out_field_skip (uiout, "line");
5376 ui_out_text (uiout, "\n");
5377 ui_out_text (uiout, extra_field_indent);
5378 ui_out_text (uiout, _("Data: \""));
5379 ui_out_field_string (uiout, "extra-data", marker->extra);
5380 ui_out_text (uiout, "\"\n");
5382 if (!VEC_empty (breakpoint_p, tracepoints))
5384 struct cleanup *cleanup_chain;
5386 struct breakpoint *b;
5388 cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
5391 ui_out_text (uiout, extra_field_indent);
5392 ui_out_text (uiout, _("Probed by static tracepoints: "));
5393 for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
5396 ui_out_text (uiout, ", ");
5397 ui_out_text (uiout, "#");
5398 ui_out_field_int (uiout, "tracepoint-id", b->number);
5401 do_cleanups (cleanup_chain);
5403 if (ui_out_is_mi_like_p (uiout))
5404 ui_out_field_int (uiout, "number-of-tracepoints",
5405 VEC_length(breakpoint_p, tracepoints));
5407 ui_out_text (uiout, "\n");
5409 VEC_free (breakpoint_p, tracepoints);
5411 do_cleanups (bkpt_chain);
5415 info_static_tracepoint_markers_command (char *arg, int from_tty)
5417 VEC(static_tracepoint_marker_p) *markers;
5418 struct cleanup *old_chain;
5419 struct static_tracepoint_marker *marker;
5420 struct ui_out *uiout = current_uiout;
5423 /* We don't have to check target_can_use_agent and agent's capability on
5424 static tracepoint here, in order to be compatible with older GDBserver.
5425 We don't check USE_AGENT is true or not, because static tracepoints
5426 don't work without in-process agent, so we don't bother users to type
5427 `set agent on' when to use static tracepoint. */
5430 = make_cleanup_ui_out_table_begin_end (uiout, 5, -1,
5431 "StaticTracepointMarkersTable");
5433 ui_out_table_header (uiout, 7, ui_left, "counter", "Cnt");
5435 ui_out_table_header (uiout, 40, ui_left, "marker-id", "ID");
5437 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
5438 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
5439 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");
5441 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
5442 ui_out_table_header (uiout, 40, ui_noalign, "what", "What");
5444 ui_out_table_body (uiout);
5446 markers = target_static_tracepoint_markers_by_strid (NULL);
5447 make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
5450 VEC_iterate (static_tracepoint_marker_p,
5451 markers, i, marker);
5454 print_one_static_tracepoint_marker (i + 1, marker);
5455 release_static_tracepoint_marker (marker);
5458 do_cleanups (old_chain);
5461 /* The $_sdata convenience variable is a bit special. We don't know
5462 for sure type of the value until we actually have a chance to fetch
5463 the data --- the size of the object depends on what has been
5464 collected. We solve this by making $_sdata be an internalvar that
5465 creates a new value on access. */
5467 /* Return a new value with the correct type for the sdata object of
5468 the current trace frame. Return a void value if there's no object
5471 static struct value *
5472 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var,
5478 /* We need to read the whole object before we know its size. */
5479 size = target_read_alloc (¤t_target,
5480 TARGET_OBJECT_STATIC_TRACE_DATA,
5487 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
5489 v = allocate_value (type);
5490 memcpy (value_contents_raw (v), buf, size);
5495 return allocate_value (builtin_type (gdbarch)->builtin_void);
5498 #if !defined(HAVE_LIBEXPAT)
5500 struct traceframe_info *
5501 parse_traceframe_info (const char *tframe_info)
5503 static int have_warned;
5508 warning (_("Can not parse XML trace frame info; XML support "
5509 "was disabled at compile time"));
5515 #else /* HAVE_LIBEXPAT */
5517 #include "xml-support.h"
5519 /* Handle the start of a <memory> element. */
5522 traceframe_info_start_memory (struct gdb_xml_parser *parser,
5523 const struct gdb_xml_element *element,
5524 void *user_data, VEC(gdb_xml_value_s) *attributes)
5526 struct traceframe_info *info = user_data;
5527 struct mem_range *r = VEC_safe_push (mem_range_s, info->memory, NULL);
5528 ULONGEST *start_p, *length_p;
5530 start_p = xml_find_attribute (attributes, "start")->value;
5531 length_p = xml_find_attribute (attributes, "length")->value;
5533 r->start = *start_p;
5534 r->length = *length_p;
5537 /* Discard the constructed trace frame info (if an error occurs). */
5540 free_result (void *p)
5542 struct traceframe_info *result = p;
5544 free_traceframe_info (result);
5547 /* The allowed elements and attributes for an XML memory map. */
5549 static const struct gdb_xml_attribute memory_attributes[] = {
5550 { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
5551 { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
5552 { NULL, GDB_XML_AF_NONE, NULL, NULL }
5555 static const struct gdb_xml_element traceframe_info_children[] = {
5556 { "memory", memory_attributes, NULL,
5557 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
5558 traceframe_info_start_memory, NULL },
5559 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
5562 static const struct gdb_xml_element traceframe_info_elements[] = {
5563 { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
5565 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
5568 /* Parse a traceframe-info XML document. */
5570 struct traceframe_info *
5571 parse_traceframe_info (const char *tframe_info)
5573 struct traceframe_info *result;
5574 struct cleanup *back_to;
5576 result = XCNEW (struct traceframe_info);
5577 back_to = make_cleanup (free_result, result);
5579 if (gdb_xml_parse_quick (_("trace frame info"),
5580 "traceframe-info.dtd", traceframe_info_elements,
5581 tframe_info, result) == 0)
5583 /* Parsed successfully, keep the result. */
5584 discard_cleanups (back_to);
5589 do_cleanups (back_to);
5593 #endif /* HAVE_LIBEXPAT */
5595 /* Returns the traceframe_info object for the current traceframe.
5596 This is where we avoid re-fetching the object from the target if we
5597 already have it cached. */
5599 static struct traceframe_info *
5600 get_traceframe_info (void)
5602 if (traceframe_info == NULL)
5603 traceframe_info = target_traceframe_info ();
5605 return traceframe_info;
5608 /* If the target supports the query, return in RESULT the set of
5609 collected memory in the current traceframe, found within the LEN
5610 bytes range starting at MEMADDR. Returns true if the target
5611 supports the query, otherwise returns false, and RESULT is left
5615 traceframe_available_memory (VEC(mem_range_s) **result,
5616 CORE_ADDR memaddr, ULONGEST len)
5618 struct traceframe_info *info = get_traceframe_info ();
5622 struct mem_range *r;
5627 for (i = 0; VEC_iterate (mem_range_s, info->memory, i, r); i++)
5628 if (mem_ranges_overlap (r->start, r->length, memaddr, len))
5630 ULONGEST lo1, hi1, lo2, hi2;
5631 struct mem_range *nr;
5634 hi1 = memaddr + len;
5637 hi2 = r->start + r->length;
5639 nr = VEC_safe_push (mem_range_s, *result, NULL);
5641 nr->start = max (lo1, lo2);
5642 nr->length = min (hi1, hi2) - nr->start;
5645 normalize_mem_ranges (*result);
5652 /* Implementation of `sdata' variable. */
5654 static const struct internalvar_funcs sdata_funcs =
5661 /* module initialization */
5663 _initialize_tracepoint (void)
5665 struct cmd_list_element *c;
5667 /* Explicitly create without lookup, since that tries to create a
5668 value with a void typed value, and when we get here, gdbarch
5669 isn't initialized yet. At this point, we're quite sure there
5670 isn't another convenience variable of the same name. */
5671 create_internalvar_type_lazy ("_sdata", &sdata_funcs, NULL);
5673 traceframe_number = -1;
5674 tracepoint_number = -1;
5676 if (tracepoint_list.list == NULL)
5678 tracepoint_list.listsize = 128;
5679 tracepoint_list.list = xmalloc
5680 (tracepoint_list.listsize * sizeof (struct memrange));
5682 if (tracepoint_list.aexpr_list == NULL)
5684 tracepoint_list.aexpr_listsize = 128;
5685 tracepoint_list.aexpr_list = xmalloc
5686 (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
5689 if (stepping_list.list == NULL)
5691 stepping_list.listsize = 128;
5692 stepping_list.list = xmalloc
5693 (stepping_list.listsize * sizeof (struct memrange));
5696 if (stepping_list.aexpr_list == NULL)
5698 stepping_list.aexpr_listsize = 128;
5699 stepping_list.aexpr_list = xmalloc
5700 (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
5703 add_info ("scope", scope_info,
5704 _("List the variables local to a scope"));
5706 add_cmd ("tracepoints", class_trace, NULL,
5707 _("Tracing of program execution without stopping the program."),
5710 add_com ("tdump", class_trace, trace_dump_command,
5711 _("Print everything collected at the current tracepoint."));
5713 add_com ("tsave", class_trace, trace_save_command, _("\
5714 Save the trace data to a file.\n\
5715 Use the '-ctf' option to save the data to CTF format.\n\
5716 Use the '-r' option to direct the target to save directly to the file,\n\
5717 using its own filesystem."));
5719 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
5720 Define a trace state variable.\n\
5721 Argument is a $-prefixed name, optionally followed\n\
5722 by '=' and an expression that sets the initial value\n\
5723 at the start of tracing."));
5724 set_cmd_completer (c, expression_completer);
5726 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
5727 Delete one or more trace state variables.\n\
5728 Arguments are the names of the variables to delete.\n\
5729 If no arguments are supplied, delete all variables."), &deletelist);
5730 /* FIXME add a trace variable completer. */
5732 add_info ("tvariables", tvariables_info, _("\
5733 Status of trace state variables and their values.\n\
5736 add_info ("static-tracepoint-markers",
5737 info_static_tracepoint_markers_command, _("\
5738 List target static tracepoints markers.\n\
5741 add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
5742 Select a trace frame;\n\
5743 No argument means forward by one frame; '-' means backward by one frame."),
5744 &tfindlist, "tfind ", 1, &cmdlist);
5746 add_cmd ("outside", class_trace, trace_find_outside_command, _("\
5747 Select a trace frame whose PC is outside the given range (exclusive).\n\
5748 Usage: tfind outside addr1, addr2"),
5751 add_cmd ("range", class_trace, trace_find_range_command, _("\
5752 Select a trace frame whose PC is in the given range (inclusive).\n\
5753 Usage: tfind range addr1,addr2"),
5756 add_cmd ("line", class_trace, trace_find_line_command, _("\
5757 Select a trace frame by source line.\n\
5758 Argument can be a line number (with optional source file),\n\
5759 a function name, or '*' followed by an address.\n\
5760 Default argument is 'the next source line that was traced'."),
5763 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
5764 Select a trace frame by tracepoint number.\n\
5765 Default is the tracepoint for the current trace frame."),
5768 add_cmd ("pc", class_trace, trace_find_pc_command, _("\
5769 Select a trace frame by PC.\n\
5770 Default is the current PC, or the PC of the current trace frame."),
5773 add_cmd ("end", class_trace, trace_find_end_command, _("\
5774 De-select any trace frame and resume 'live' debugging."),
5777 add_alias_cmd ("none", "end", class_trace, 0, &tfindlist);
5779 add_cmd ("start", class_trace, trace_find_start_command,
5780 _("Select the first trace frame in the trace buffer."),
5783 add_com ("tstatus", class_trace, trace_status_command,
5784 _("Display the status of the current trace data collection."));
5786 add_com ("tstop", class_trace, trace_stop_command, _("\
5787 Stop trace data collection.\n\
5788 Usage: tstop [ <notes> ... ]\n\
5789 Any arguments supplied are recorded with the trace as a stop reason and\n\
5790 reported by tstatus (if the target supports trace notes)."));
5792 add_com ("tstart", class_trace, trace_start_command, _("\
5793 Start trace data collection.\n\
5794 Usage: tstart [ <notes> ... ]\n\
5795 Any arguments supplied are recorded with the trace as a note and\n\
5796 reported by tstatus (if the target supports trace notes)."));
5798 add_com ("end", class_trace, end_actions_pseudocommand, _("\
5799 Ends a list of commands or actions.\n\
5800 Several GDB commands allow you to enter a list of commands or actions.\n\
5801 Entering \"end\" on a line by itself is the normal way to terminate\n\
5803 Note: the \"end\" command cannot be used at the gdb prompt."));
5805 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
5806 Specify single-stepping behavior at a tracepoint.\n\
5807 Argument is number of instructions to trace in single-step mode\n\
5808 following the tracepoint. This command is normally followed by\n\
5809 one or more \"collect\" commands, to specify what to collect\n\
5810 while single-stepping.\n\n\
5811 Note: this command can only be used in a tracepoint \"actions\" list."));
5813 add_com_alias ("ws", "while-stepping", class_alias, 0);
5814 add_com_alias ("stepping", "while-stepping", class_alias, 0);
5816 add_com ("collect", class_trace, collect_pseudocommand, _("\
5817 Specify one or more data items to be collected at a tracepoint.\n\
5818 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5819 collect all data (variables, registers) referenced by that expression.\n\
5820 Also accepts the following special arguments:\n\
5821 $regs -- all registers.\n\
5822 $args -- all function arguments.\n\
5823 $locals -- all variables local to the block/function scope.\n\
5824 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5825 Note: this command can only be used in a tracepoint \"actions\" list."));
5827 add_com ("teval", class_trace, teval_pseudocommand, _("\
5828 Specify one or more expressions to be evaluated at a tracepoint.\n\
5829 Accepts a comma-separated list of (one or more) expressions.\n\
5830 The result of each evaluation will be discarded.\n\
5831 Note: this command can only be used in a tracepoint \"actions\" list."));
5833 add_com ("actions", class_trace, trace_actions_command, _("\
5834 Specify the actions to be taken at a tracepoint.\n\
5835 Tracepoint actions may include collecting of specified data,\n\
5836 single-stepping, or enabling/disabling other tracepoints,\n\
5837 depending on target's capabilities."));
5839 default_collect = xstrdup ("");
5840 add_setshow_string_cmd ("default-collect", class_trace,
5841 &default_collect, _("\
5842 Set the list of expressions to collect by default"), _("\
5843 Show the list of expressions to collect by default"), NULL,
5845 &setlist, &showlist);
5847 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
5848 &disconnected_tracing, _("\
5849 Set whether tracing continues after GDB disconnects."), _("\
5850 Show whether tracing continues after GDB disconnects."), _("\
5851 Use this to continue a tracing run even if GDB disconnects\n\
5852 or detaches from the target. You can reconnect later and look at\n\
5853 trace data collected in the meantime."),
5854 set_disconnected_tracing,
5859 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
5860 &circular_trace_buffer, _("\
5861 Set target's use of circular trace buffer."), _("\
5862 Show target's use of circular trace buffer."), _("\
5863 Use this to make the trace buffer into a circular buffer,\n\
5864 which will discard traceframes (oldest first) instead of filling\n\
5865 up and stopping the trace run."),
5866 set_circular_trace_buffer,
5871 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class,
5872 &trace_buffer_size, _("\
5873 Set requested size of trace buffer."), _("\
5874 Show requested size of trace buffer."), _("\
5875 Use this to choose a size for the trace buffer. Some targets\n\
5876 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
5877 disables any attempt to set the buffer size and lets the target choose."),
5878 set_trace_buffer_size, NULL,
5879 &setlist, &showlist);
5881 add_setshow_string_cmd ("trace-user", class_trace,
5883 Set the user name to use for current and future trace runs"), _("\
5884 Show the user name to use for current and future trace runs"), NULL,
5885 set_trace_user, NULL,
5886 &setlist, &showlist);
5888 add_setshow_string_cmd ("trace-notes", class_trace,
5890 Set notes string to use for current and future trace runs"), _("\
5891 Show the notes string to use for current and future trace runs"), NULL,
5892 set_trace_notes, NULL,
5893 &setlist, &showlist);
5895 add_setshow_string_cmd ("trace-stop-notes", class_trace,
5896 &trace_stop_notes, _("\
5897 Set notes string to use for future tstop commands"), _("\
5898 Show the notes string to use for future tstop commands"), NULL,
5899 set_trace_stop_notes, NULL,
5900 &setlist, &showlist);
5904 add_target_with_completer (&tfile_ops, filename_completer);