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
878 /* MEMRANGE functions: */
880 static int memrange_cmp (const void *, const void *);
882 /* Compare memranges for qsort. */
884 memrange_cmp (const void *va, const void *vb)
886 const struct memrange *a = va, *b = vb;
888 if (a->type < b->type)
890 if (a->type > b->type)
892 if (a->type == memrange_absolute)
894 if ((bfd_vma) a->start < (bfd_vma) b->start)
896 if ((bfd_vma) a->start > (bfd_vma) b->start)
901 if (a->start < b->start)
903 if (a->start > b->start)
909 /* Sort the memrange list using qsort, and merge adjacent memranges. */
911 memrange_sortmerge (struct collection_list *memranges)
915 qsort (memranges->list, memranges->next_memrange,
916 sizeof (struct memrange), memrange_cmp);
917 if (memranges->next_memrange > 0)
919 for (a = 0, b = 1; b < memranges->next_memrange; b++)
921 /* If memrange b overlaps or is adjacent to memrange a,
923 if (memranges->list[a].type == memranges->list[b].type
924 && memranges->list[b].start <= memranges->list[a].end)
926 if (memranges->list[b].end > memranges->list[a].end)
927 memranges->list[a].end = memranges->list[b].end;
928 continue; /* next b, same a */
932 memcpy (&memranges->list[a], &memranges->list[b],
933 sizeof (struct memrange));
935 memranges->next_memrange = a + 1;
939 /* Add a register to a collection list. */
941 add_register (struct collection_list *collection, unsigned int regno)
944 printf_filtered ("collect register %d\n", regno);
945 if (regno >= (8 * sizeof (collection->regs_mask)))
946 error (_("Internal: register number %d too large for tracepoint"),
948 collection->regs_mask[regno / 8] |= 1 << (regno % 8);
951 /* Add a memrange to a collection list. */
953 add_memrange (struct collection_list *memranges,
954 int type, bfd_signed_vma base,
959 printf_filtered ("(%d,", type);
961 printf_filtered (",%ld)\n", len);
964 /* type: memrange_absolute == memory, other n == basereg */
965 memranges->list[memranges->next_memrange].type = type;
966 /* base: addr if memory, offset if reg relative. */
967 memranges->list[memranges->next_memrange].start = base;
968 /* len: we actually save end (base + len) for convenience */
969 memranges->list[memranges->next_memrange].end = base + len;
970 memranges->next_memrange++;
971 if (memranges->next_memrange >= memranges->listsize)
973 memranges->listsize *= 2;
974 memranges->list = xrealloc (memranges->list,
975 memranges->listsize);
978 if (type != memrange_absolute) /* Better collect the base register! */
979 add_register (memranges, type);
982 /* Add a symbol to a collection list. */
984 collect_symbol (struct collection_list *collect,
986 struct gdbarch *gdbarch,
987 long frame_regno, long frame_offset,
993 bfd_signed_vma offset;
994 int treat_as_expr = 0;
996 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
997 switch (SYMBOL_CLASS (sym))
1000 printf_filtered ("%s: don't know symbol class %d\n",
1001 SYMBOL_PRINT_NAME (sym),
1002 SYMBOL_CLASS (sym));
1005 printf_filtered ("constant %s (value %s) will not be collected.\n",
1006 SYMBOL_PRINT_NAME (sym), plongest (SYMBOL_VALUE (sym)));
1009 offset = SYMBOL_VALUE_ADDRESS (sym);
1014 sprintf_vma (tmp, offset);
1015 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1016 SYMBOL_PRINT_NAME (sym), len,
1019 /* A struct may be a C++ class with static fields, go to general
1020 expression handling. */
1021 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
1024 add_memrange (collect, memrange_absolute, offset, len);
1027 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
1029 printf_filtered ("LOC_REG[parm] %s: ",
1030 SYMBOL_PRINT_NAME (sym));
1031 add_register (collect, reg);
1032 /* Check for doubles stored in two registers. */
1033 /* FIXME: how about larger types stored in 3 or more regs? */
1034 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
1035 len > register_size (gdbarch, reg))
1036 add_register (collect, reg + 1);
1039 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1040 printf_filtered (" (will not collect %s)\n",
1041 SYMBOL_PRINT_NAME (sym));
1045 offset = frame_offset + SYMBOL_VALUE (sym);
1048 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1049 SYMBOL_PRINT_NAME (sym), len);
1050 printf_vma (offset);
1051 printf_filtered (" from frame ptr reg %d\n", reg);
1053 add_memrange (collect, reg, offset, len);
1055 case LOC_REGPARM_ADDR:
1056 reg = SYMBOL_VALUE (sym);
1060 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1061 SYMBOL_PRINT_NAME (sym), len);
1062 printf_vma (offset);
1063 printf_filtered (" from reg %d\n", reg);
1065 add_memrange (collect, reg, offset, len);
1069 offset = frame_offset + SYMBOL_VALUE (sym);
1072 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1073 SYMBOL_PRINT_NAME (sym), len);
1074 printf_vma (offset);
1075 printf_filtered (" from frame ptr reg %d\n", reg);
1077 add_memrange (collect, reg, offset, len);
1080 case LOC_UNRESOLVED:
1084 case LOC_OPTIMIZED_OUT:
1085 printf_filtered ("%s has been optimized out of existence.\n",
1086 SYMBOL_PRINT_NAME (sym));
1094 /* Expressions are the most general case. */
1097 struct agent_expr *aexpr;
1098 struct cleanup *old_chain1 = NULL;
1100 aexpr = gen_trace_for_var (scope, gdbarch, sym, trace_string);
1102 /* It can happen that the symbol is recorded as a computed
1103 location, but it's been optimized away and doesn't actually
1104 have a location expression. */
1107 printf_filtered ("%s has been optimized out of existence.\n",
1108 SYMBOL_PRINT_NAME (sym));
1112 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1116 report_agent_reqs_errors (aexpr);
1118 discard_cleanups (old_chain1);
1119 add_aexpr (collect, aexpr);
1121 /* Take care of the registers. */
1122 if (aexpr->reg_mask_len > 0)
1126 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1128 QUIT; /* Allow user to bail out with ^C. */
1129 if (aexpr->reg_mask[ndx1] != 0)
1131 /* Assume chars have 8 bits. */
1132 for (ndx2 = 0; ndx2 < 8; ndx2++)
1133 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1134 /* It's used -- record it. */
1135 add_register (collect, ndx1 * 8 + ndx2);
1142 /* Data to be passed around in the calls to the locals and args
1145 struct add_local_symbols_data
1147 struct collection_list *collect;
1148 struct gdbarch *gdbarch;
1156 /* The callback for the locals and args iterators. */
1159 do_collect_symbol (const char *print_name,
1163 struct add_local_symbols_data *p = cb_data;
1165 collect_symbol (p->collect, sym, p->gdbarch, p->frame_regno,
1166 p->frame_offset, p->pc, p->trace_string);
1170 /* Add all locals (or args) symbols to collection list. */
1172 add_local_symbols (struct collection_list *collect,
1173 struct gdbarch *gdbarch, CORE_ADDR pc,
1174 long frame_regno, long frame_offset, int type,
1177 struct block *block;
1178 struct add_local_symbols_data cb_data;
1180 cb_data.collect = collect;
1181 cb_data.gdbarch = gdbarch;
1183 cb_data.frame_regno = frame_regno;
1184 cb_data.frame_offset = frame_offset;
1186 cb_data.trace_string = trace_string;
1190 block = block_for_pc (pc);
1193 warning (_("Can't collect locals; "
1194 "no symbol table info available.\n"));
1198 iterate_over_block_local_vars (block, do_collect_symbol, &cb_data);
1199 if (cb_data.count == 0)
1200 warning (_("No locals found in scope."));
1204 pc = get_pc_function_start (pc);
1205 block = block_for_pc (pc);
1208 warning (_("Can't collect args; no symbol table info available."));
1212 iterate_over_block_arg_vars (block, do_collect_symbol, &cb_data);
1213 if (cb_data.count == 0)
1214 warning (_("No args found in scope."));
1219 add_static_trace_data (struct collection_list *collection)
1222 printf_filtered ("collect static trace data\n");
1223 collection->strace_data = 1;
1226 /* worker function */
1228 clear_collection_list (struct collection_list *list)
1232 list->next_memrange = 0;
1233 for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1235 free_agent_expr (list->aexpr_list[ndx]);
1236 list->aexpr_list[ndx] = NULL;
1238 list->next_aexpr_elt = 0;
1239 memset (list->regs_mask, 0, sizeof (list->regs_mask));
1240 list->strace_data = 0;
1242 xfree (list->aexpr_list);
1246 /* A cleanup wrapper for function clear_collection_list. */
1249 do_clear_collection_list (void *list)
1251 struct collection_list *l = list;
1253 clear_collection_list (l);
1256 /* Initialize collection_list CLIST. */
1259 init_collection_list (struct collection_list *clist)
1261 memset (clist, 0, sizeof *clist);
1263 clist->listsize = 128;
1264 clist->list = xcalloc (clist->listsize,
1265 sizeof (struct memrange));
1267 clist->aexpr_listsize = 128;
1268 clist->aexpr_list = xcalloc (clist->aexpr_listsize,
1269 sizeof (struct agent_expr *));
1272 /* Reduce a collection list to string form (for gdb protocol). */
1274 stringify_collection_list (struct collection_list *list)
1276 char temp_buf[2048];
1280 char *(*str_list)[];
1284 count = 1 + 1 + list->next_memrange + list->next_aexpr_elt + 1;
1285 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1287 if (list->strace_data)
1290 printf_filtered ("\nCollecting static trace data\n");
1293 (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
1297 for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1298 if (list->regs_mask[i] != 0) /* Skip leading zeroes in regs_mask. */
1300 if (list->regs_mask[i] != 0) /* Prepare to send regs_mask to the stub. */
1303 printf_filtered ("\nCollecting registers (mask): 0x");
1308 QUIT; /* Allow user to bail out with ^C. */
1310 printf_filtered ("%02X", list->regs_mask[i]);
1311 sprintf (end, "%02X", list->regs_mask[i]);
1314 (*str_list)[ndx] = xstrdup (temp_buf);
1318 printf_filtered ("\n");
1319 if (list->next_memrange > 0 && info_verbose)
1320 printf_filtered ("Collecting memranges: \n");
1321 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1323 QUIT; /* Allow user to bail out with ^C. */
1324 sprintf_vma (tmp2, list->list[i].start);
1327 printf_filtered ("(%d, %s, %ld)\n",
1330 (long) (list->list[i].end - list->list[i].start));
1332 if (count + 27 > MAX_AGENT_EXPR_LEN)
1334 (*str_list)[ndx] = savestring (temp_buf, count);
1341 bfd_signed_vma length = list->list[i].end - list->list[i].start;
1343 /* The "%X" conversion specifier expects an unsigned argument,
1344 so passing -1 (memrange_absolute) to it directly gives you
1345 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1347 if (list->list[i].type == memrange_absolute)
1348 sprintf (end, "M-1,%s,%lX", tmp2, (long) length);
1350 sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length);
1353 count += strlen (end);
1354 end = temp_buf + count;
1357 for (i = 0; i < list->next_aexpr_elt; i++)
1359 QUIT; /* Allow user to bail out with ^C. */
1360 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1362 (*str_list)[ndx] = savestring (temp_buf, count);
1367 sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1368 end += 10; /* 'X' + 8 hex digits + ',' */
1371 end = mem2hex (list->aexpr_list[i]->buf,
1372 end, list->aexpr_list[i]->len);
1373 count += 2 * list->aexpr_list[i]->len;
1378 (*str_list)[ndx] = savestring (temp_buf, count);
1383 (*str_list)[ndx] = NULL;
1396 encode_actions_1 (struct command_line *action,
1397 struct bp_location *tloc,
1399 LONGEST frame_offset,
1400 struct collection_list *collect,
1401 struct collection_list *stepping_list)
1403 const char *action_exp;
1404 struct expression *exp = NULL;
1406 struct value *tempval;
1407 struct cmd_list_element *cmd;
1408 struct agent_expr *aexpr;
1410 for (; action; action = action->next)
1412 QUIT; /* Allow user to bail out with ^C. */
1413 action_exp = action->line;
1414 action_exp = skip_spaces_const (action_exp);
1416 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1418 error (_("Bad action list item: %s"), action_exp);
1420 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1422 int trace_string = 0;
1424 if (*action_exp == '/')
1425 action_exp = decode_agent_options (action_exp, &trace_string);
1428 { /* Repeat over a comma-separated list. */
1429 QUIT; /* Allow user to bail out with ^C. */
1430 action_exp = skip_spaces_const (action_exp);
1432 if (0 == strncasecmp ("$reg", action_exp, 4))
1434 for (i = 0; i < gdbarch_num_regs (tloc->gdbarch); i++)
1435 add_register (collect, i);
1436 action_exp = strchr (action_exp, ','); /* more? */
1438 else if (0 == strncasecmp ("$arg", action_exp, 4))
1440 add_local_symbols (collect,
1447 action_exp = strchr (action_exp, ','); /* more? */
1449 else if (0 == strncasecmp ("$loc", action_exp, 4))
1451 add_local_symbols (collect,
1458 action_exp = strchr (action_exp, ','); /* more? */
1460 else if (0 == strncasecmp ("$_ret", action_exp, 5))
1462 struct cleanup *old_chain1 = NULL;
1464 aexpr = gen_trace_for_return_address (tloc->address,
1468 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1471 report_agent_reqs_errors (aexpr);
1473 discard_cleanups (old_chain1);
1474 add_aexpr (collect, aexpr);
1476 /* take care of the registers */
1477 if (aexpr->reg_mask_len > 0)
1481 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1483 QUIT; /* allow user to bail out with ^C */
1484 if (aexpr->reg_mask[ndx1] != 0)
1486 /* assume chars have 8 bits */
1487 for (ndx2 = 0; ndx2 < 8; ndx2++)
1488 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1489 /* it's used -- record it */
1490 add_register (collect,
1496 action_exp = strchr (action_exp, ','); /* more? */
1498 else if (0 == strncasecmp ("$_sdata", action_exp, 7))
1500 add_static_trace_data (collect);
1501 action_exp = strchr (action_exp, ','); /* more? */
1506 struct cleanup *old_chain = NULL;
1507 struct cleanup *old_chain1 = NULL;
1509 exp = parse_exp_1 (&action_exp, tloc->address,
1510 block_for_pc (tloc->address), 1);
1511 old_chain = make_cleanup (free_current_contents, &exp);
1513 switch (exp->elts[0].opcode)
1517 const char *name = &exp->elts[2].string;
1519 i = user_reg_map_name_to_regnum (tloc->gdbarch,
1520 name, strlen (name));
1522 internal_error (__FILE__, __LINE__,
1523 _("Register $%s not available"),
1526 printf_filtered ("OP_REGISTER: ");
1527 add_register (collect, i);
1532 /* Safe because we know it's a simple expression. */
1533 tempval = evaluate_expression (exp);
1534 addr = value_address (tempval);
1535 /* Initialize the TYPE_LENGTH if it is a typedef. */
1536 check_typedef (exp->elts[1].type);
1537 add_memrange (collect, memrange_absolute, addr,
1538 TYPE_LENGTH (exp->elts[1].type));
1542 collect_symbol (collect,
1543 exp->elts[2].symbol,
1551 default: /* Full-fledged expression. */
1552 aexpr = gen_trace_for_expr (tloc->address, exp,
1555 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1559 report_agent_reqs_errors (aexpr);
1561 discard_cleanups (old_chain1);
1562 add_aexpr (collect, aexpr);
1564 /* Take care of the registers. */
1565 if (aexpr->reg_mask_len > 0)
1570 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1572 QUIT; /* Allow user to bail out with ^C. */
1573 if (aexpr->reg_mask[ndx1] != 0)
1575 /* Assume chars have 8 bits. */
1576 for (ndx2 = 0; ndx2 < 8; ndx2++)
1577 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1578 /* It's used -- record it. */
1579 add_register (collect,
1586 do_cleanups (old_chain);
1589 while (action_exp && *action_exp++ == ',');
1591 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1594 { /* Repeat over a comma-separated list. */
1595 QUIT; /* Allow user to bail out with ^C. */
1596 action_exp = skip_spaces_const (action_exp);
1599 struct cleanup *old_chain = NULL;
1600 struct cleanup *old_chain1 = NULL;
1602 exp = parse_exp_1 (&action_exp, tloc->address,
1603 block_for_pc (tloc->address), 1);
1604 old_chain = make_cleanup (free_current_contents, &exp);
1606 aexpr = gen_eval_for_expr (tloc->address, exp);
1607 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1610 report_agent_reqs_errors (aexpr);
1612 discard_cleanups (old_chain1);
1613 /* Even though we're not officially collecting, add
1614 to the collect list anyway. */
1615 add_aexpr (collect, aexpr);
1617 do_cleanups (old_chain);
1620 while (action_exp && *action_exp++ == ',');
1622 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1624 /* We check against nested while-stepping when setting
1625 breakpoint action, so no way to run into nested
1627 gdb_assert (stepping_list);
1629 encode_actions_1 (action->body_list[0], tloc, frame_reg,
1630 frame_offset, stepping_list, NULL);
1633 error (_("Invalid tracepoint command '%s'"), action->line);
1637 /* Render all actions into gdb protocol. */
1640 encode_actions (struct bp_location *tloc, char ***tdp_actions,
1641 char ***stepping_actions)
1643 char *default_collect_line = NULL;
1644 struct command_line *actions;
1645 struct command_line *default_collect_action = NULL;
1647 LONGEST frame_offset;
1648 struct cleanup *back_to;
1649 struct collection_list tracepoint_list, stepping_list;
1651 back_to = make_cleanup (null_cleanup, NULL);
1653 init_collection_list (&tracepoint_list);
1654 init_collection_list (&stepping_list);
1656 make_cleanup (do_clear_collection_list, &tracepoint_list);
1657 make_cleanup (do_clear_collection_list, &stepping_list);
1659 *tdp_actions = NULL;
1660 *stepping_actions = NULL;
1662 gdbarch_virtual_frame_pointer (tloc->gdbarch,
1663 tloc->address, &frame_reg, &frame_offset);
1665 actions = all_tracepoint_actions_and_cleanup (tloc->owner);
1667 encode_actions_1 (actions, tloc, frame_reg, frame_offset,
1668 &tracepoint_list, &stepping_list);
1670 memrange_sortmerge (&tracepoint_list);
1671 memrange_sortmerge (&stepping_list);
1673 *tdp_actions = stringify_collection_list (&tracepoint_list);
1674 *stepping_actions = stringify_collection_list (&stepping_list);
1676 do_cleanups (back_to);
1680 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
1682 if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1684 collect->aexpr_list =
1685 xrealloc (collect->aexpr_list,
1686 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
1687 collect->aexpr_listsize *= 2;
1689 collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1690 collect->next_aexpr_elt++;
1694 process_tracepoint_on_disconnect (void)
1696 VEC(breakpoint_p) *tp_vec = NULL;
1698 struct breakpoint *b;
1699 int has_pending_p = 0;
1701 /* Check whether we still have pending tracepoint. If we have, warn the
1702 user that pending tracepoint will no longer work. */
1703 tp_vec = all_tracepoints ();
1704 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1713 struct bp_location *loc1;
1715 for (loc1 = b->loc; loc1; loc1 = loc1->next)
1717 if (loc1->shlib_disabled)
1728 VEC_free (breakpoint_p, tp_vec);
1731 warning (_("Pending tracepoints will not be resolved while"
1732 " GDB is disconnected\n"));
1735 /* Reset local state of tracing. */
1738 trace_reset_local_state (void)
1740 set_traceframe_num (-1);
1741 set_tracepoint_num (-1);
1742 set_traceframe_context (NULL);
1743 clear_traceframe_info ();
1747 start_tracing (char *notes)
1749 VEC(breakpoint_p) *tp_vec = NULL;
1751 struct breakpoint *b;
1752 struct trace_state_variable *tsv;
1753 int any_enabled = 0, num_to_download = 0;
1756 tp_vec = all_tracepoints ();
1758 /* No point in tracing without any tracepoints... */
1759 if (VEC_length (breakpoint_p, tp_vec) == 0)
1761 VEC_free (breakpoint_p, tp_vec);
1762 error (_("No tracepoints defined, not starting trace"));
1765 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1767 struct tracepoint *t = (struct tracepoint *) b;
1768 struct bp_location *loc;
1770 if (b->enable_state == bp_enabled)
1773 if ((b->type == bp_fast_tracepoint
1774 ? may_insert_fast_tracepoints
1775 : may_insert_tracepoints))
1778 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1779 (b->type == bp_fast_tracepoint ? "fast " : ""), b->number);
1784 if (target_supports_enable_disable_tracepoint ())
1785 warning (_("No tracepoints enabled"));
1788 /* No point in tracing with only disabled tracepoints that
1789 cannot be re-enabled. */
1790 VEC_free (breakpoint_p, tp_vec);
1791 error (_("No tracepoints enabled, not starting trace"));
1795 if (num_to_download <= 0)
1797 VEC_free (breakpoint_p, tp_vec);
1798 error (_("No tracepoints that may be downloaded, not starting trace"));
1801 target_trace_init ();
1803 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1805 struct tracepoint *t = (struct tracepoint *) b;
1806 struct bp_location *loc;
1807 int bp_location_downloaded = 0;
1809 /* Clear `inserted' flag. */
1810 for (loc = b->loc; loc; loc = loc->next)
1813 if ((b->type == bp_fast_tracepoint
1814 ? !may_insert_fast_tracepoints
1815 : !may_insert_tracepoints))
1818 t->number_on_target = 0;
1820 for (loc = b->loc; loc; loc = loc->next)
1822 /* Since tracepoint locations are never duplicated, `inserted'
1823 flag should be zero. */
1824 gdb_assert (!loc->inserted);
1826 target_download_tracepoint (loc);
1829 bp_location_downloaded = 1;
1832 t->number_on_target = b->number;
1834 for (loc = b->loc; loc; loc = loc->next)
1835 if (loc->probe != NULL)
1836 loc->probe->pops->set_semaphore (loc->probe, loc->gdbarch);
1838 if (bp_location_downloaded)
1839 observer_notify_breakpoint_modified (b);
1841 VEC_free (breakpoint_p, tp_vec);
1843 /* Send down all the trace state variables too. */
1844 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1846 target_download_trace_state_variable (tsv);
1849 /* Tell target to treat text-like sections as transparent. */
1850 target_trace_set_readonly_regions ();
1851 /* Set some mode flags. */
1852 target_set_disconnected_tracing (disconnected_tracing);
1853 target_set_circular_trace_buffer (circular_trace_buffer);
1854 target_set_trace_buffer_size (trace_buffer_size);
1857 notes = trace_notes;
1858 ret = target_set_trace_notes (trace_user, notes, NULL);
1860 if (!ret && (trace_user || notes))
1861 warning (_("Target does not support trace user/notes, info ignored"));
1863 /* Now insert traps and begin collecting data. */
1864 target_trace_start ();
1866 /* Reset our local state. */
1867 trace_reset_local_state ();
1868 current_trace_status()->running = 1;
1871 /* The tstart command requests the target to start a new trace run.
1872 The command passes any arguments it has to the target verbatim, as
1873 an optional "trace note". This is useful as for instance a warning
1874 to other users if the trace runs disconnected, and you don't want
1875 anybody else messing with the target. */
1878 trace_start_command (char *args, int from_tty)
1880 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1882 if (current_trace_status ()->running)
1885 && !query (_("A trace is running already. Start a new run? ")))
1886 error (_("New trace run not started."));
1889 start_tracing (args);
1892 /* The tstop command stops the tracing run. The command passes any
1893 supplied arguments to the target verbatim as a "stop note"; if the
1894 target supports trace notes, then it will be reported back as part
1895 of the trace run's status. */
1898 trace_stop_command (char *args, int from_tty)
1900 if (!current_trace_status ()->running)
1901 error (_("Trace is not running."));
1903 stop_tracing (args);
1907 stop_tracing (char *note)
1910 VEC(breakpoint_p) *tp_vec = NULL;
1912 struct breakpoint *t;
1914 target_trace_stop ();
1916 tp_vec = all_tracepoints ();
1917 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1919 struct bp_location *loc;
1921 if ((t->type == bp_fast_tracepoint
1922 ? !may_insert_fast_tracepoints
1923 : !may_insert_tracepoints))
1926 for (loc = t->loc; loc; loc = loc->next)
1928 /* GDB can be totally absent in some disconnected trace scenarios,
1929 but we don't really care if this semaphore goes out of sync.
1930 That's why we are decrementing it here, but not taking care
1932 if (loc->probe != NULL)
1933 loc->probe->pops->clear_semaphore (loc->probe, loc->gdbarch);
1937 VEC_free (breakpoint_p, tp_vec);
1940 note = trace_stop_notes;
1941 ret = target_set_trace_notes (NULL, NULL, note);
1944 warning (_("Target does not support trace notes, note ignored"));
1946 /* Should change in response to reply? */
1947 current_trace_status ()->running = 0;
1950 /* tstatus command */
1952 trace_status_command (char *args, int from_tty)
1954 struct trace_status *ts = current_trace_status ();
1956 VEC(breakpoint_p) *tp_vec = NULL;
1957 struct breakpoint *t;
1959 status = target_get_trace_status (ts);
1963 if (ts->filename != NULL)
1964 printf_filtered (_("Using a trace file.\n"));
1967 printf_filtered (_("Trace can not be run on this target.\n"));
1972 if (!ts->running_known)
1974 printf_filtered (_("Run/stop status is unknown.\n"));
1976 else if (ts->running)
1978 printf_filtered (_("Trace is running on the target.\n"));
1982 switch (ts->stop_reason)
1984 case trace_never_run:
1985 printf_filtered (_("No trace has been run on the target.\n"));
1989 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1992 printf_filtered (_("Trace stopped by a tstop command.\n"));
1994 case trace_buffer_full:
1995 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1997 case trace_disconnected:
1998 printf_filtered (_("Trace stopped because of disconnection.\n"));
2000 case tracepoint_passcount:
2001 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
2002 ts->stopping_tracepoint);
2004 case tracepoint_error:
2005 if (ts->stopping_tracepoint)
2006 printf_filtered (_("Trace stopped by an "
2007 "error (%s, tracepoint %d).\n"),
2008 ts->stop_desc, ts->stopping_tracepoint);
2010 printf_filtered (_("Trace stopped by an error (%s).\n"),
2013 case trace_stop_reason_unknown:
2014 printf_filtered (_("Trace stopped for an unknown reason.\n"));
2017 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
2023 if (ts->traceframes_created >= 0
2024 && ts->traceframe_count != ts->traceframes_created)
2026 printf_filtered (_("Buffer contains %d trace "
2027 "frames (of %d created total).\n"),
2028 ts->traceframe_count, ts->traceframes_created);
2030 else if (ts->traceframe_count >= 0)
2032 printf_filtered (_("Collected %d trace frames.\n"),
2033 ts->traceframe_count);
2036 if (ts->buffer_free >= 0)
2038 if (ts->buffer_size >= 0)
2040 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2041 ts->buffer_free, ts->buffer_size);
2042 if (ts->buffer_size > 0)
2043 printf_filtered (_(" (%d%% full)"),
2044 ((int) ((((long long) (ts->buffer_size
2045 - ts->buffer_free)) * 100)
2046 / ts->buffer_size)));
2047 printf_filtered (_(".\n"));
2050 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2054 if (ts->disconnected_tracing)
2055 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2057 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2059 if (ts->circular_buffer)
2060 printf_filtered (_("Trace buffer is circular.\n"));
2062 if (ts->user_name && strlen (ts->user_name) > 0)
2063 printf_filtered (_("Trace user is %s.\n"), ts->user_name);
2065 if (ts->notes && strlen (ts->notes) > 0)
2066 printf_filtered (_("Trace notes: %s.\n"), ts->notes);
2068 /* Now report on what we're doing with tfind. */
2069 if (traceframe_number >= 0)
2070 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2071 traceframe_number, tracepoint_number);
2073 printf_filtered (_("Not looking at any trace frame.\n"));
2075 /* Report start/stop times if supplied. */
2080 LONGEST run_time = ts->stop_time - ts->start_time;
2082 /* Reporting a run time is more readable than two long numbers. */
2083 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2084 (long int) ts->start_time / 1000000,
2085 (long int) ts->start_time % 1000000,
2086 (long int) run_time / 1000000,
2087 (long int) run_time % 1000000);
2090 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2091 (long int) ts->start_time / 1000000,
2092 (long int) ts->start_time % 1000000);
2094 else if (ts->stop_time)
2095 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2096 (long int) ts->stop_time / 1000000,
2097 (long int) ts->stop_time % 1000000);
2099 /* Now report any per-tracepoint status available. */
2100 tp_vec = all_tracepoints ();
2102 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
2103 target_get_tracepoint_status (t, NULL);
2105 VEC_free (breakpoint_p, tp_vec);
2108 /* Report the trace status to uiout, in a way suitable for MI, and not
2109 suitable for CLI. If ON_STOP is true, suppress a few fields that
2110 are not meaningful in the -trace-stop response.
2112 The implementation is essentially parallel to trace_status_command, but
2113 merging them will result in unreadable code. */
2115 trace_status_mi (int on_stop)
2117 struct ui_out *uiout = current_uiout;
2118 struct trace_status *ts = current_trace_status ();
2121 status = target_get_trace_status (ts);
2123 if (status == -1 && ts->filename == NULL)
2125 ui_out_field_string (uiout, "supported", "0");
2129 if (ts->filename != NULL)
2130 ui_out_field_string (uiout, "supported", "file");
2132 ui_out_field_string (uiout, "supported", "1");
2134 if (ts->filename != NULL)
2135 ui_out_field_string (uiout, "trace-file", ts->filename);
2137 gdb_assert (ts->running_known);
2141 ui_out_field_string (uiout, "running", "1");
2143 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2144 Given that the frontend gets the status either on -trace-stop, or from
2145 -trace-status after re-connection, it does not seem like this
2146 information is necessary for anything. It is not necessary for either
2147 figuring the vital state of the target nor for navigation of trace
2148 frames. If the frontend wants to show the current state is some
2149 configure dialog, it can request the value when such dialog is
2150 invoked by the user. */
2154 char *stop_reason = NULL;
2155 int stopping_tracepoint = -1;
2158 ui_out_field_string (uiout, "running", "0");
2160 if (ts->stop_reason != trace_stop_reason_unknown)
2162 switch (ts->stop_reason)
2165 stop_reason = "request";
2167 case trace_buffer_full:
2168 stop_reason = "overflow";
2170 case trace_disconnected:
2171 stop_reason = "disconnection";
2173 case tracepoint_passcount:
2174 stop_reason = "passcount";
2175 stopping_tracepoint = ts->stopping_tracepoint;
2177 case tracepoint_error:
2178 stop_reason = "error";
2179 stopping_tracepoint = ts->stopping_tracepoint;
2185 ui_out_field_string (uiout, "stop-reason", stop_reason);
2186 if (stopping_tracepoint != -1)
2187 ui_out_field_int (uiout, "stopping-tracepoint",
2188 stopping_tracepoint);
2189 if (ts->stop_reason == tracepoint_error)
2190 ui_out_field_string (uiout, "error-description",
2196 if (ts->traceframe_count != -1)
2197 ui_out_field_int (uiout, "frames", ts->traceframe_count);
2198 if (ts->traceframes_created != -1)
2199 ui_out_field_int (uiout, "frames-created", ts->traceframes_created);
2200 if (ts->buffer_size != -1)
2201 ui_out_field_int (uiout, "buffer-size", ts->buffer_size);
2202 if (ts->buffer_free != -1)
2203 ui_out_field_int (uiout, "buffer-free", ts->buffer_free);
2205 ui_out_field_int (uiout, "disconnected", ts->disconnected_tracing);
2206 ui_out_field_int (uiout, "circular", ts->circular_buffer);
2208 ui_out_field_string (uiout, "user-name", ts->user_name);
2209 ui_out_field_string (uiout, "notes", ts->notes);
2214 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2215 (long int) ts->start_time / 1000000,
2216 (long int) ts->start_time % 1000000);
2217 ui_out_field_string (uiout, "start-time", buf);
2218 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2219 (long int) ts->stop_time / 1000000,
2220 (long int) ts->stop_time % 1000000);
2221 ui_out_field_string (uiout, "stop-time", buf);
2225 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2226 user if she really wants to detach. */
2229 query_if_trace_running (int from_tty)
2234 /* It can happen that the target that was tracing went away on its
2235 own, and we didn't notice. Get a status update, and if the
2236 current target doesn't even do tracing, then assume it's not
2238 if (target_get_trace_status (current_trace_status ()) < 0)
2239 current_trace_status ()->running = 0;
2241 /* If running interactively, give the user the option to cancel and
2242 then decide what to do differently with the run. Scripts are
2243 just going to disconnect and let the target deal with it,
2244 according to how it's been instructed previously via
2245 disconnected-tracing. */
2246 if (current_trace_status ()->running)
2248 process_tracepoint_on_disconnect ();
2250 if (current_trace_status ()->disconnected_tracing)
2252 if (!query (_("Trace is running and will "
2253 "continue after detach; detach anyway? ")))
2254 error (_("Not confirmed."));
2258 if (!query (_("Trace is running but will "
2259 "stop on detach; detach anyway? ")))
2260 error (_("Not confirmed."));
2265 /* This function handles the details of what to do about an ongoing
2266 tracing run if the user has asked to detach or otherwise disconnect
2270 disconnect_tracing (void)
2272 /* Also we want to be out of tfind mode, otherwise things can get
2273 confusing upon reconnection. Just use these calls instead of
2274 full tfind_1 behavior because we're in the middle of detaching,
2275 and there's no point to updating current stack frame etc. */
2276 trace_reset_local_state ();
2279 /* Worker function for the various flavors of the tfind command. */
2281 tfind_1 (enum trace_find_type type, int num,
2282 CORE_ADDR addr1, CORE_ADDR addr2,
2285 int target_frameno = -1, target_tracept = -1;
2286 struct frame_id old_frame_id = null_frame_id;
2287 struct tracepoint *tp;
2288 struct ui_out *uiout = current_uiout;
2290 /* Only try to get the current stack frame if we have a chance of
2291 succeeding. In particular, if we're trying to get a first trace
2292 frame while all threads are running, it's not going to succeed,
2293 so leave it with a default value and let the frame comparison
2294 below (correctly) decide to print out the source location of the
2296 if (!(type == tfind_number && num == -1)
2297 && (has_stack_frames () || traceframe_number >= 0))
2298 old_frame_id = get_frame_id (get_current_frame ());
2300 target_frameno = target_trace_find (type, num, addr1, addr2,
2303 if (type == tfind_number
2305 && target_frameno == -1)
2307 /* We told the target to get out of tfind mode, and it did. */
2309 else if (target_frameno == -1)
2311 /* A request for a non-existent trace frame has failed.
2312 Our response will be different, depending on FROM_TTY:
2314 If FROM_TTY is true, meaning that this command was
2315 typed interactively by the user, then give an error
2316 and DO NOT change the state of traceframe_number etc.
2318 However if FROM_TTY is false, meaning that we're either
2319 in a script, a loop, or a user-defined command, then
2320 DON'T give an error, but DO change the state of
2321 traceframe_number etc. to invalid.
2323 The rationalle is that if you typed the command, you
2324 might just have committed a typo or something, and you'd
2325 like to NOT lose your current debugging state. However
2326 if you're in a user-defined command or especially in a
2327 loop, then you need a way to detect that the command
2328 failed WITHOUT aborting. This allows you to write
2329 scripts that search thru the trace buffer until the end,
2330 and then continue on to do something else. */
2333 error (_("Target failed to find requested trace frame."));
2337 printf_filtered ("End of trace buffer.\n");
2338 #if 0 /* dubious now? */
2339 /* The following will not recurse, since it's
2341 trace_find_command ("-1", from_tty);
2346 tp = get_tracepoint_by_number_on_target (target_tracept);
2348 reinit_frame_cache ();
2349 target_dcache_invalidate ();
2351 set_tracepoint_num (tp ? tp->base.number : target_tracept);
2353 if (target_frameno != get_traceframe_number ())
2354 observer_notify_traceframe_changed (target_frameno, tracepoint_number);
2356 set_current_traceframe (target_frameno);
2358 if (target_frameno == -1)
2359 set_traceframe_context (NULL);
2361 set_traceframe_context (get_current_frame ());
2363 if (traceframe_number >= 0)
2365 /* Use different branches for MI and CLI to make CLI messages
2367 if (ui_out_is_mi_like_p (uiout))
2369 ui_out_field_string (uiout, "found", "1");
2370 ui_out_field_int (uiout, "tracepoint", tracepoint_number);
2371 ui_out_field_int (uiout, "traceframe", traceframe_number);
2375 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2376 traceframe_number, tracepoint_number);
2381 if (ui_out_is_mi_like_p (uiout))
2382 ui_out_field_string (uiout, "found", "0");
2383 else if (type == tfind_number && num == -1)
2384 printf_unfiltered (_("No longer looking at any trace frame\n"));
2385 else /* This case may never occur, check. */
2386 printf_unfiltered (_("No trace frame found\n"));
2389 /* If we're in nonstop mode and getting out of looking at trace
2390 frames, there won't be any current frame to go back to and
2393 && (has_stack_frames () || traceframe_number >= 0))
2395 enum print_what print_what;
2397 /* NOTE: in imitation of the step command, try to determine
2398 whether we have made a transition from one function to
2399 another. If so, we'll print the "stack frame" (ie. the new
2400 function and it's arguments) -- otherwise we'll just show the
2403 if (frame_id_eq (old_frame_id,
2404 get_frame_id (get_current_frame ())))
2405 print_what = SRC_LINE;
2407 print_what = SRC_AND_LOC;
2409 print_stack_frame (get_selected_frame (NULL), 1, print_what);
2414 /* trace_find_command takes a trace frame number n,
2415 sends "QTFrame:<n>" to the target,
2416 and accepts a reply that may contain several optional pieces
2417 of information: a frame number, a tracepoint number, and an
2418 indication of whether this is a trap frame or a stepping frame.
2420 The minimal response is just "OK" (which indicates that the
2421 target does not give us a frame number or a tracepoint number).
2422 Instead of that, the target may send us a string containing
2424 F<hexnum> (gives the selected frame number)
2425 T<hexnum> (gives the selected tracepoint number)
2430 trace_find_command (char *args, int from_tty)
2431 { /* This should only be called with a numeric argument. */
2434 if (current_trace_status ()->running
2435 && current_trace_status ()->filename == NULL)
2436 error (_("May not look at trace frames while trace is running."));
2438 if (args == 0 || *args == 0)
2439 { /* TFIND with no args means find NEXT trace frame. */
2440 if (traceframe_number == -1)
2441 frameno = 0; /* "next" is first one. */
2443 frameno = traceframe_number + 1;
2445 else if (0 == strcmp (args, "-"))
2447 if (traceframe_number == -1)
2448 error (_("not debugging trace buffer"));
2449 else if (from_tty && traceframe_number == 0)
2450 error (_("already at start of trace buffer"));
2452 frameno = traceframe_number - 1;
2454 /* A hack to work around eval's need for fp to have been collected. */
2455 else if (0 == strcmp (args, "-1"))
2458 frameno = parse_and_eval_long (args);
2461 error (_("invalid input (%d is less than zero)"), frameno);
2463 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2468 trace_find_end_command (char *args, int from_tty)
2470 trace_find_command ("-1", from_tty);
2475 trace_find_start_command (char *args, int from_tty)
2477 trace_find_command ("0", from_tty);
2480 /* tfind pc command */
2482 trace_find_pc_command (char *args, int from_tty)
2486 if (current_trace_status ()->running
2487 && current_trace_status ()->filename == NULL)
2488 error (_("May not look at trace frames while trace is running."));
2490 if (args == 0 || *args == 0)
2491 pc = regcache_read_pc (get_current_regcache ());
2493 pc = parse_and_eval_address (args);
2495 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2498 /* tfind tracepoint command */
2500 trace_find_tracepoint_command (char *args, int from_tty)
2503 struct tracepoint *tp;
2505 if (current_trace_status ()->running
2506 && current_trace_status ()->filename == NULL)
2507 error (_("May not look at trace frames while trace is running."));
2509 if (args == 0 || *args == 0)
2511 if (tracepoint_number == -1)
2512 error (_("No current tracepoint -- please supply an argument."));
2514 tdp = tracepoint_number; /* Default is current TDP. */
2517 tdp = parse_and_eval_long (args);
2519 /* If we have the tracepoint on hand, use the number that the
2520 target knows about (which may be different if we disconnected
2521 and reconnected). */
2522 tp = get_tracepoint (tdp);
2524 tdp = tp->number_on_target;
2526 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2529 /* TFIND LINE command:
2531 This command will take a sourceline for argument, just like BREAK
2532 or TRACE (ie. anything that "decode_line_1" can handle).
2534 With no argument, this command will find the next trace frame
2535 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2538 trace_find_line_command (char *args, int from_tty)
2540 static CORE_ADDR start_pc, end_pc;
2541 struct symtabs_and_lines sals;
2542 struct symtab_and_line sal;
2543 struct cleanup *old_chain;
2545 if (current_trace_status ()->running
2546 && current_trace_status ()->filename == NULL)
2547 error (_("May not look at trace frames while trace is running."));
2549 if (args == 0 || *args == 0)
2551 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2553 sals.sals = (struct symtab_and_line *)
2554 xmalloc (sizeof (struct symtab_and_line));
2559 sals = decode_line_with_current_source (args, DECODE_LINE_FUNFIRSTLINE);
2563 old_chain = make_cleanup (xfree, sals.sals);
2564 if (sal.symtab == 0)
2565 error (_("No line number information available."));
2567 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2569 if (start_pc == end_pc)
2571 printf_filtered ("Line %d of \"%s\"",
2573 symtab_to_filename_for_display (sal.symtab));
2575 printf_filtered (" is at address ");
2576 print_address (get_current_arch (), start_pc, gdb_stdout);
2578 printf_filtered (" but contains no code.\n");
2579 sal = find_pc_line (start_pc, 0);
2581 && find_line_pc_range (sal, &start_pc, &end_pc)
2582 && start_pc != end_pc)
2583 printf_filtered ("Attempting to find line %d instead.\n",
2586 error (_("Cannot find a good line."));
2590 /* Is there any case in which we get here, and have an address
2591 which the user would want to see? If we have debugging
2592 symbols and no line numbers? */
2593 error (_("Line number %d is out of range for \"%s\"."),
2594 sal.line, symtab_to_filename_for_display (sal.symtab));
2596 /* Find within range of stated line. */
2598 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2600 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2601 do_cleanups (old_chain);
2604 /* tfind range command */
2606 trace_find_range_command (char *args, int from_tty)
2608 static CORE_ADDR start, stop;
2611 if (current_trace_status ()->running
2612 && current_trace_status ()->filename == NULL)
2613 error (_("May not look at trace frames while trace is running."));
2615 if (args == 0 || *args == 0)
2616 { /* XXX FIXME: what should default behavior be? */
2617 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2621 if (0 != (tmp = strchr (args, ',')))
2623 *tmp++ = '\0'; /* Terminate start address. */
2624 tmp = skip_spaces (tmp);
2625 start = parse_and_eval_address (args);
2626 stop = parse_and_eval_address (tmp);
2629 { /* No explicit end address? */
2630 start = parse_and_eval_address (args);
2631 stop = start + 1; /* ??? */
2634 tfind_1 (tfind_range, 0, start, stop, from_tty);
2637 /* tfind outside command */
2639 trace_find_outside_command (char *args, int from_tty)
2641 CORE_ADDR start, stop;
2644 if (current_trace_status ()->running
2645 && current_trace_status ()->filename == NULL)
2646 error (_("May not look at trace frames while trace is running."));
2648 if (args == 0 || *args == 0)
2649 { /* XXX FIXME: what should default behavior be? */
2650 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2654 if (0 != (tmp = strchr (args, ',')))
2656 *tmp++ = '\0'; /* Terminate start address. */
2657 tmp = skip_spaces (tmp);
2658 start = parse_and_eval_address (args);
2659 stop = parse_and_eval_address (tmp);
2662 { /* No explicit end address? */
2663 start = parse_and_eval_address (args);
2664 stop = start + 1; /* ??? */
2667 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2670 /* info scope command: list the locals for a scope. */
2672 scope_info (char *args, int from_tty)
2674 struct symtabs_and_lines sals;
2676 struct minimal_symbol *msym;
2677 struct block *block;
2678 const char *symname;
2679 char *save_args = args;
2680 struct block_iterator iter;
2682 struct gdbarch *gdbarch;
2685 if (args == 0 || *args == 0)
2686 error (_("requires an argument (function, "
2687 "line or *addr) to define a scope"));
2689 sals = decode_line_1 (&args, DECODE_LINE_FUNFIRSTLINE, NULL, 0);
2690 if (sals.nelts == 0)
2691 return; /* Presumably decode_line_1 has already warned. */
2693 /* Resolve line numbers to PC. */
2694 resolve_sal_pc (&sals.sals[0]);
2695 block = block_for_pc (sals.sals[0].pc);
2699 QUIT; /* Allow user to bail out with ^C. */
2700 ALL_BLOCK_SYMBOLS (block, iter, sym)
2702 QUIT; /* Allow user to bail out with ^C. */
2704 printf_filtered ("Scope for %s:\n", save_args);
2707 symname = SYMBOL_PRINT_NAME (sym);
2708 if (symname == NULL || *symname == '\0')
2709 continue; /* Probably botched, certainly useless. */
2711 gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
2713 printf_filtered ("Symbol %s is ", symname);
2715 if (SYMBOL_COMPUTED_OPS (sym) != NULL)
2716 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2717 BLOCK_START (block),
2721 switch (SYMBOL_CLASS (sym))
2724 case LOC_UNDEF: /* Messed up symbol? */
2725 printf_filtered ("a bogus symbol, class %d.\n",
2726 SYMBOL_CLASS (sym));
2727 count--; /* Don't count this one. */
2730 printf_filtered ("a constant with value %s (%s)",
2731 plongest (SYMBOL_VALUE (sym)),
2732 hex_string (SYMBOL_VALUE (sym)));
2734 case LOC_CONST_BYTES:
2735 printf_filtered ("constant bytes: ");
2736 if (SYMBOL_TYPE (sym))
2737 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2738 fprintf_filtered (gdb_stdout, " %02x",
2739 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2742 printf_filtered ("in static storage at address ");
2743 printf_filtered ("%s", paddress (gdbarch,
2744 SYMBOL_VALUE_ADDRESS (sym)));
2747 /* GDBARCH is the architecture associated with the objfile
2748 the symbol is defined in; the target architecture may be
2749 different, and may provide additional registers. However,
2750 we do not know the target architecture at this point.
2751 We assume the objfile architecture will contain all the
2752 standard registers that occur in debug info in that
2754 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2757 if (SYMBOL_IS_ARGUMENT (sym))
2758 printf_filtered ("an argument in register $%s",
2759 gdbarch_register_name (gdbarch, regno));
2761 printf_filtered ("a local variable in register $%s",
2762 gdbarch_register_name (gdbarch, regno));
2765 printf_filtered ("an argument at stack/frame offset %s",
2766 plongest (SYMBOL_VALUE (sym)));
2769 printf_filtered ("a local variable at frame offset %s",
2770 plongest (SYMBOL_VALUE (sym)));
2773 printf_filtered ("a reference argument at offset %s",
2774 plongest (SYMBOL_VALUE (sym)));
2776 case LOC_REGPARM_ADDR:
2777 /* Note comment at LOC_REGISTER. */
2778 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2780 printf_filtered ("the address of an argument, in register $%s",
2781 gdbarch_register_name (gdbarch, regno));
2784 printf_filtered ("a typedef.\n");
2787 printf_filtered ("a label at address ");
2788 printf_filtered ("%s", paddress (gdbarch,
2789 SYMBOL_VALUE_ADDRESS (sym)));
2792 printf_filtered ("a function at address ");
2793 printf_filtered ("%s",
2794 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2796 case LOC_UNRESOLVED:
2797 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2800 printf_filtered ("Unresolved Static");
2803 printf_filtered ("static storage at address ");
2804 printf_filtered ("%s",
2806 SYMBOL_VALUE_ADDRESS (msym)));
2809 case LOC_OPTIMIZED_OUT:
2810 printf_filtered ("optimized out.\n");
2813 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2816 if (SYMBOL_TYPE (sym))
2817 printf_filtered (", length %d.\n",
2818 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2820 if (BLOCK_FUNCTION (block))
2823 block = BLOCK_SUPERBLOCK (block);
2826 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2830 /* Helper for trace_dump_command. Dump the action list starting at
2831 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2832 actions of the body of a while-stepping action. STEPPING_FRAME is
2833 set if the current traceframe was determined to be a while-stepping
2837 trace_dump_actions (struct command_line *action,
2838 int stepping_actions, int stepping_frame,
2841 const char *action_exp, *next_comma;
2843 for (; action != NULL; action = action->next)
2845 struct cmd_list_element *cmd;
2847 QUIT; /* Allow user to bail out with ^C. */
2848 action_exp = action->line;
2849 action_exp = skip_spaces_const (action_exp);
2851 /* The collection actions to be done while stepping are
2852 bracketed by the commands "while-stepping" and "end". */
2854 if (*action_exp == '#') /* comment line */
2857 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2859 error (_("Bad action list item: %s"), action_exp);
2861 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2865 for (i = 0; i < action->body_count; ++i)
2866 trace_dump_actions (action->body_list[i],
2867 1, stepping_frame, from_tty);
2869 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2871 /* Display the collected data.
2872 For the trap frame, display only what was collected at
2873 the trap. Likewise for stepping frames, display only
2874 what was collected while stepping. This means that the
2875 two boolean variables, STEPPING_FRAME and
2876 STEPPING_ACTIONS should be equal. */
2877 if (stepping_frame == stepping_actions)
2880 struct cleanup *old_chain
2881 = make_cleanup (free_current_contents, &cmd);
2882 int trace_string = 0;
2884 if (*action_exp == '/')
2885 action_exp = decode_agent_options (action_exp, &trace_string);
2888 { /* Repeat over a comma-separated list. */
2889 QUIT; /* Allow user to bail out with ^C. */
2890 if (*action_exp == ',')
2892 action_exp = skip_spaces_const (action_exp);
2894 next_comma = strchr (action_exp, ',');
2896 if (0 == strncasecmp (action_exp, "$reg", 4))
2897 registers_info (NULL, from_tty);
2898 else if (0 == strncasecmp (action_exp, "$_ret", 5))
2900 else if (0 == strncasecmp (action_exp, "$loc", 4))
2901 locals_info (NULL, from_tty);
2902 else if (0 == strncasecmp (action_exp, "$arg", 4))
2903 args_info (NULL, from_tty);
2906 if (next_comma != NULL)
2908 size_t len = next_comma - action_exp;
2910 cmd = xrealloc (cmd, len + 1);
2911 memcpy (cmd, action_exp, len);
2916 size_t len = strlen (action_exp);
2918 cmd = xrealloc (cmd, len + 1);
2919 memcpy (cmd, action_exp, len + 1);
2922 printf_filtered ("%s = ", cmd);
2923 output_command_const (cmd, from_tty);
2924 printf_filtered ("\n");
2926 action_exp = next_comma;
2928 while (action_exp && *action_exp == ',');
2930 do_cleanups (old_chain);
2936 /* Return all the actions, including default collect, of a tracepoint
2937 T. It constructs cleanups into the chain, and leaves the caller to
2938 handle them (call do_cleanups). */
2940 static struct command_line *
2941 all_tracepoint_actions_and_cleanup (struct breakpoint *t)
2943 struct command_line *actions;
2945 actions = breakpoint_commands (t);
2947 /* If there are default expressions to collect, make up a collect
2948 action and prepend to the action list to encode. Note that since
2949 validation is per-tracepoint (local var "xyz" might be valid for
2950 one tracepoint and not another, etc), we make up the action on
2951 the fly, and don't cache it. */
2952 if (*default_collect)
2954 struct command_line *default_collect_action;
2955 char *default_collect_line;
2957 default_collect_line = xstrprintf ("collect %s", default_collect);
2958 make_cleanup (xfree, default_collect_line);
2960 validate_actionline (default_collect_line, t);
2961 default_collect_action = xmalloc (sizeof (struct command_line));
2962 make_cleanup (xfree, default_collect_action);
2963 default_collect_action->next = actions;
2964 default_collect_action->line = default_collect_line;
2965 actions = default_collect_action;
2971 /* The tdump command. */
2974 trace_dump_command (char *args, int from_tty)
2976 struct regcache *regcache;
2977 struct tracepoint *t;
2978 int stepping_frame = 0;
2979 struct bp_location *loc;
2980 char *default_collect_line = NULL;
2981 struct command_line *actions, *default_collect_action = NULL;
2982 struct cleanup *old_chain;
2984 if (tracepoint_number == -1)
2985 error (_("No current trace frame."));
2987 old_chain = make_cleanup (null_cleanup, NULL);
2988 t = get_tracepoint (tracepoint_number);
2991 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2994 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2995 tracepoint_number, traceframe_number);
2997 /* The current frame is a trap frame if the frame PC is equal
2998 to the tracepoint PC. If not, then the current frame was
2999 collected during single-stepping. */
3001 regcache = get_current_regcache ();
3003 /* If the traceframe's address matches any of the tracepoint's
3004 locations, assume it is a direct hit rather than a while-stepping
3005 frame. (FIXME this is not reliable, should record each frame's
3008 for (loc = t->base.loc; loc; loc = loc->next)
3009 if (loc->address == regcache_read_pc (regcache))
3012 actions = all_tracepoint_actions_and_cleanup (&t->base);
3014 trace_dump_actions (actions, 0, stepping_frame, from_tty);
3016 do_cleanups (old_chain);
3019 /* Encode a piece of a tracepoint's source-level definition in a form
3020 that is suitable for both protocol and saving in files. */
3021 /* This version does not do multiple encodes for long strings; it should
3022 return an offset to the next piece to encode. FIXME */
3025 encode_source_string (int tpnum, ULONGEST addr,
3026 char *srctype, char *src, char *buf, int buf_size)
3028 if (80 + strlen (srctype) > buf_size)
3029 error (_("Buffer too small for source encoding"));
3030 sprintf (buf, "%x:%s:%s:%x:%x:",
3031 tpnum, phex_nz (addr, sizeof (addr)),
3032 srctype, 0, (int) strlen (src));
3033 if (strlen (buf) + strlen (src) * 2 >= buf_size)
3034 error (_("Source string too long for buffer"));
3035 bin2hex ((gdb_byte *) src, buf + strlen (buf), 0);
3039 /* Free trace file writer. */
3042 trace_file_writer_xfree (void *arg)
3044 struct trace_file_writer *writer = arg;
3046 writer->ops->dtor (writer);
3050 /* TFILE trace writer. */
3052 struct tfile_trace_file_writer
3054 struct trace_file_writer base;
3056 /* File pointer to tfile trace file. */
3058 /* Path name of the tfile trace file. */
3062 /* This is the implementation of trace_file_write_ops method
3063 target_save. We just call the generic target
3064 target_save_trace_data to do target-side saving. */
3067 tfile_target_save (struct trace_file_writer *self,
3068 const char *filename)
3070 int err = target_save_trace_data (filename);
3075 /* This is the implementation of trace_file_write_ops method
3079 tfile_dtor (struct trace_file_writer *self)
3081 struct tfile_trace_file_writer *writer
3082 = (struct tfile_trace_file_writer *) self;
3084 xfree (writer->pathname);
3086 if (writer->fp != NULL)
3087 fclose (writer->fp);
3090 /* This is the implementation of trace_file_write_ops method
3091 start. It creates the trace file FILENAME and registers some
3095 tfile_start (struct trace_file_writer *self, const char *filename)
3097 struct tfile_trace_file_writer *writer
3098 = (struct tfile_trace_file_writer *) self;
3100 writer->pathname = tilde_expand (filename);
3101 writer->fp = gdb_fopen_cloexec (writer->pathname, "wb");
3102 if (writer->fp == NULL)
3103 error (_("Unable to open file '%s' for saving trace data (%s)"),
3104 filename, safe_strerror (errno));
3107 /* This is the implementation of trace_file_write_ops method
3108 write_header. Write the TFILE header. */
3111 tfile_write_header (struct trace_file_writer *self)
3113 struct tfile_trace_file_writer *writer
3114 = (struct tfile_trace_file_writer *) self;
3117 /* Write a file header, with a high-bit-set char to indicate a
3118 binary file, plus a hint as what this file is, and a version
3119 number in case of future needs. */
3120 written = fwrite ("\x7fTRACE0\n", 8, 1, writer->fp);
3122 perror_with_name (writer->pathname);
3125 /* This is the implementation of trace_file_write_ops method
3126 write_regblock_type. Write the size of register block. */
3129 tfile_write_regblock_type (struct trace_file_writer *self, int size)
3131 struct tfile_trace_file_writer *writer
3132 = (struct tfile_trace_file_writer *) self;
3134 fprintf (writer->fp, "R %x\n", size);
3137 /* This is the implementation of trace_file_write_ops method
3141 tfile_write_status (struct trace_file_writer *self,
3142 struct trace_status *ts)
3144 struct tfile_trace_file_writer *writer
3145 = (struct tfile_trace_file_writer *) self;
3147 fprintf (writer->fp, "status %c;%s",
3148 (ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
3149 if (ts->stop_reason == tracepoint_error
3150 || ts->stop_reason == tstop_command)
3152 char *buf = (char *) alloca (strlen (ts->stop_desc) * 2 + 1);
3154 bin2hex ((gdb_byte *) ts->stop_desc, buf, 0);
3155 fprintf (writer->fp, ":%s", buf);
3157 fprintf (writer->fp, ":%x", ts->stopping_tracepoint);
3158 if (ts->traceframe_count >= 0)
3159 fprintf (writer->fp, ";tframes:%x", ts->traceframe_count);
3160 if (ts->traceframes_created >= 0)
3161 fprintf (writer->fp, ";tcreated:%x", ts->traceframes_created);
3162 if (ts->buffer_free >= 0)
3163 fprintf (writer->fp, ";tfree:%x", ts->buffer_free);
3164 if (ts->buffer_size >= 0)
3165 fprintf (writer->fp, ";tsize:%x", ts->buffer_size);
3166 if (ts->disconnected_tracing)
3167 fprintf (writer->fp, ";disconn:%x", ts->disconnected_tracing);
3168 if (ts->circular_buffer)
3169 fprintf (writer->fp, ";circular:%x", ts->circular_buffer);
3170 if (ts->notes != NULL)
3172 char *buf = (char *) alloca (strlen (ts->notes) * 2 + 1);
3174 bin2hex ((gdb_byte *) ts->notes, buf, 0);
3175 fprintf (writer->fp, ";notes:%s", buf);
3177 if (ts->user_name != NULL)
3179 char *buf = (char *) alloca (strlen (ts->user_name) * 2 + 1);
3181 bin2hex ((gdb_byte *) ts->user_name, buf, 0);
3182 fprintf (writer->fp, ";username:%s", buf);
3184 fprintf (writer->fp, "\n");
3187 /* This is the implementation of trace_file_write_ops method
3188 write_uploaded_tsv. */
3191 tfile_write_uploaded_tsv (struct trace_file_writer *self,
3192 struct uploaded_tsv *utsv)
3195 struct tfile_trace_file_writer *writer
3196 = (struct tfile_trace_file_writer *) self;
3200 buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
3201 bin2hex ((gdb_byte *) (utsv->name), buf, 0);
3204 fprintf (writer->fp, "tsv %x:%s:%x:%s\n",
3205 utsv->number, phex_nz (utsv->initial_value, 8),
3206 utsv->builtin, buf);
3212 #define MAX_TRACE_UPLOAD 2000
3214 /* This is the implementation of trace_file_write_ops method
3215 write_uploaded_tp. */
3218 tfile_write_uploaded_tp (struct trace_file_writer *self,
3219 struct uploaded_tp *utp)
3221 struct tfile_trace_file_writer *writer
3222 = (struct tfile_trace_file_writer *) self;
3225 char buf[MAX_TRACE_UPLOAD];
3227 fprintf (writer->fp, "tp T%x:%s:%c:%x:%x",
3228 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
3229 (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
3230 if (utp->type == bp_fast_tracepoint)
3231 fprintf (writer->fp, ":F%x", utp->orig_size);
3233 fprintf (writer->fp,
3234 ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
3236 fprintf (writer->fp, "\n");
3237 for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
3238 fprintf (writer->fp, "tp A%x:%s:%s\n",
3239 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
3240 for (a = 0; VEC_iterate (char_ptr, utp->step_actions, a, act); ++a)
3241 fprintf (writer->fp, "tp S%x:%s:%s\n",
3242 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
3245 encode_source_string (utp->number, utp->addr,
3246 "at", utp->at_string, buf, MAX_TRACE_UPLOAD);
3247 fprintf (writer->fp, "tp Z%s\n", buf);
3249 if (utp->cond_string)
3251 encode_source_string (utp->number, utp->addr,
3252 "cond", utp->cond_string,
3253 buf, MAX_TRACE_UPLOAD);
3254 fprintf (writer->fp, "tp Z%s\n", buf);
3256 for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
3258 encode_source_string (utp->number, utp->addr, "cmd", act,
3259 buf, MAX_TRACE_UPLOAD);
3260 fprintf (writer->fp, "tp Z%s\n", buf);
3262 fprintf (writer->fp, "tp V%x:%s:%x:%s\n",
3263 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
3265 phex_nz (utp->traceframe_usage,
3266 sizeof (utp->traceframe_usage)));
3269 /* This is the implementation of trace_file_write_ops method
3270 write_definition_end. */
3273 tfile_write_definition_end (struct trace_file_writer *self)
3275 struct tfile_trace_file_writer *writer
3276 = (struct tfile_trace_file_writer *) self;
3278 fprintf (writer->fp, "\n");
3281 /* This is the implementation of trace_file_write_ops method
3285 tfile_write_raw_data (struct trace_file_writer *self, gdb_byte *buf,
3288 struct tfile_trace_file_writer *writer
3289 = (struct tfile_trace_file_writer *) self;
3291 if (fwrite (buf, len, 1, writer->fp) < 1)
3292 perror_with_name (writer->pathname);
3295 /* This is the implementation of trace_file_write_ops method
3299 tfile_end (struct trace_file_writer *self)
3301 struct tfile_trace_file_writer *writer
3302 = (struct tfile_trace_file_writer *) self;
3303 uint32_t gotten = 0;
3305 /* Mark the end of trace data. */
3306 if (fwrite (&gotten, 4, 1, writer->fp) < 1)
3307 perror_with_name (writer->pathname);
3310 /* Operations to write trace buffers into TFILE format. */
3312 static const struct trace_file_write_ops tfile_write_ops =
3318 tfile_write_regblock_type,
3320 tfile_write_uploaded_tsv,
3321 tfile_write_uploaded_tp,
3322 tfile_write_definition_end,
3323 tfile_write_raw_data,
3328 /* Helper macros. */
3330 #define TRACE_WRITE_R_BLOCK(writer, buf, size) \
3331 writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
3332 #define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size) \
3333 writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
3335 #define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size) \
3336 writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
3338 #define TRACE_WRITE_V_BLOCK(writer, num, val) \
3339 writer->ops->frame_ops->write_v_block ((writer), (num), (val))
3341 /* Save tracepoint data to file named FILENAME through WRITER. WRITER
3342 determines the trace file format. If TARGET_DOES_SAVE is non-zero,
3343 the save is performed on the target, otherwise GDB obtains all trace
3344 data and saves it locally. */
3347 trace_save (const char *filename, struct trace_file_writer *writer,
3348 int target_does_save)
3350 struct trace_status *ts = current_trace_status ();
3352 struct uploaded_tp *uploaded_tps = NULL, *utp;
3353 struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
3355 ULONGEST offset = 0;
3356 gdb_byte buf[MAX_TRACE_UPLOAD];
3357 #define MAX_TRACE_UPLOAD 2000
3359 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
3361 /* If the target is to save the data to a file on its own, then just
3362 send the command and be done with it. */
3363 if (target_does_save)
3365 if (!writer->ops->target_save (writer, filename))
3366 error (_("Target failed to save trace data to '%s'."),
3371 /* Get the trace status first before opening the file, so if the
3372 target is losing, we can get out without touching files. */
3373 status = target_get_trace_status (ts);
3375 writer->ops->start (writer, filename);
3377 writer->ops->write_header (writer);
3379 /* Write descriptive info. */
3381 /* Write out the size of a register block. */
3382 writer->ops->write_regblock_type (writer, trace_regblock_size);
3384 /* Write out status of the tracing run (aka "tstatus" info). */
3385 writer->ops->write_status (writer, ts);
3387 /* Note that we want to upload tracepoints and save those, rather
3388 than simply writing out the local ones, because the user may have
3389 changed tracepoints in GDB in preparation for a future tracing
3390 run, or maybe just mass-deleted all types of breakpoints as part
3391 of cleaning up. So as not to contaminate the session, leave the
3392 data in its uploaded form, don't make into real tracepoints. */
3394 /* Get trace state variables first, they may be checked when parsing
3395 uploaded commands. */
3397 target_upload_trace_state_variables (&uploaded_tsvs);
3399 for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
3400 writer->ops->write_uploaded_tsv (writer, utsv);
3402 free_uploaded_tsvs (&uploaded_tsvs);
3404 target_upload_tracepoints (&uploaded_tps);
3406 for (utp = uploaded_tps; utp; utp = utp->next)
3407 target_get_tracepoint_status (NULL, utp);
3409 for (utp = uploaded_tps; utp; utp = utp->next)
3410 writer->ops->write_uploaded_tp (writer, utp);
3412 free_uploaded_tps (&uploaded_tps);
3414 /* Mark the end of the definition section. */
3415 writer->ops->write_definition_end (writer);
3417 /* Get and write the trace data proper. */
3422 /* The writer supports writing the contents of trace buffer
3423 directly to trace file. Don't parse the contents of trace
3425 if (writer->ops->write_trace_buffer != NULL)
3427 /* We ask for big blocks, in the hopes of efficiency, but
3428 will take less if the target has packet size limitations
3430 gotten = target_get_raw_trace_data (buf, offset,
3433 error (_("Failure to get requested trace buffer data"));
3434 /* No more data is forthcoming, we're done. */
3438 writer->ops->write_trace_buffer (writer, buf, gotten);
3446 /* Parse the trace buffers according to how data are stored
3447 in trace buffer in GDBserver. */
3449 gotten = target_get_raw_trace_data (buf, offset, 6);
3454 /* Read the first six bytes in, which is the tracepoint
3455 number and trace frame size. */
3457 extract_unsigned_integer (&buf[0], 2, byte_order);
3459 tf_size = (uint32_t)
3460 extract_unsigned_integer (&buf[2], 4, byte_order);
3462 writer->ops->frame_ops->start (writer, tp_num);
3471 for (block = 0; block < tf_size; )
3473 gdb_byte block_type;
3475 /* We'll fetch one block each time, in order to
3476 handle the extremely large 'M' block. We first
3477 fetch one byte to get the type of the block. */
3478 gotten = target_get_raw_trace_data (buf, offset, 1);
3480 error (_("Failure to get requested trace buffer data"));
3486 block_type = buf[0];
3491 = target_get_raw_trace_data (buf, offset,
3492 trace_regblock_size);
3493 if (gotten < trace_regblock_size)
3494 error (_("Failure to get requested trace"
3497 TRACE_WRITE_R_BLOCK (writer, buf,
3498 trace_regblock_size);
3502 unsigned short mlen;
3507 t = target_get_raw_trace_data (buf,offset, 10);
3509 error (_("Failure to get requested trace"
3517 extract_unsigned_integer (buf, 8,
3519 mlen = (unsigned short)
3520 extract_unsigned_integer (&buf[8], 2,
3523 TRACE_WRITE_M_BLOCK_HEADER (writer, addr,
3526 /* The memory contents in 'M' block may be
3527 very large. Fetch the data from the target
3528 and write them into file one by one. */
3529 for (j = 0; j < mlen; )
3531 unsigned int read_length;
3533 if (mlen - j > MAX_TRACE_UPLOAD)
3534 read_length = MAX_TRACE_UPLOAD;
3536 read_length = mlen - j;
3538 t = target_get_raw_trace_data (buf,
3541 if (t < read_length)
3542 error (_("Failure to get requested"
3543 " trace buffer data"));
3545 TRACE_WRITE_M_BLOCK_MEMORY (writer, buf,
3549 gotten += read_length;
3560 = target_get_raw_trace_data (buf, offset,
3563 error (_("Failure to get requested"
3564 " trace buffer data"));
3566 vnum = (int) extract_signed_integer (buf,
3570 = extract_signed_integer (&buf[4], 8,
3573 TRACE_WRITE_V_BLOCK (writer, vnum, val);
3577 error (_("Unknown block type '%c' (0x%x) in"
3579 block_type, block_type);
3589 writer->ops->frame_ops->end (writer);
3593 writer->ops->end (writer);
3596 /* Return a trace writer for TFILE format. */
3598 static struct trace_file_writer *
3599 tfile_trace_file_writer_new (void)
3601 struct tfile_trace_file_writer *writer
3602 = xmalloc (sizeof (struct tfile_trace_file_writer));
3604 writer->base.ops = &tfile_write_ops;
3606 writer->pathname = NULL;
3608 return (struct trace_file_writer *) writer;
3612 trace_save_command (char *args, int from_tty)
3614 int target_does_save = 0;
3616 char *filename = NULL;
3617 struct cleanup *back_to;
3618 int generate_ctf = 0;
3619 struct trace_file_writer *writer = NULL;
3622 error_no_arg (_("file in which to save trace data"));
3624 argv = gdb_buildargv (args);
3625 back_to = make_cleanup_freeargv (argv);
3627 for (; *argv; ++argv)
3629 if (strcmp (*argv, "-r") == 0)
3630 target_does_save = 1;
3631 if (strcmp (*argv, "-ctf") == 0)
3633 else if (**argv == '-')
3634 error (_("unknown option `%s'"), *argv);
3640 error_no_arg (_("file in which to save trace data"));
3643 writer = ctf_trace_file_writer_new ();
3645 writer = tfile_trace_file_writer_new ();
3647 make_cleanup (trace_file_writer_xfree, writer);
3649 trace_save (filename, writer, target_does_save);
3652 printf_filtered (_("Trace data saved to %s '%s'.\n"),
3653 generate_ctf ? "directory" : "file", filename);
3655 do_cleanups (back_to);
3658 /* Save the trace data to file FILENAME of tfile format. */
3661 trace_save_tfile (const char *filename, int target_does_save)
3663 struct trace_file_writer *writer;
3664 struct cleanup *back_to;
3666 writer = tfile_trace_file_writer_new ();
3667 back_to = make_cleanup (trace_file_writer_xfree, writer);
3668 trace_save (filename, writer, target_does_save);
3669 do_cleanups (back_to);
3672 /* Save the trace data to dir DIRNAME of ctf format. */
3675 trace_save_ctf (const char *dirname, int target_does_save)
3677 struct trace_file_writer *writer;
3678 struct cleanup *back_to;
3680 writer = ctf_trace_file_writer_new ();
3681 back_to = make_cleanup (trace_file_writer_xfree, writer);
3683 trace_save (dirname, writer, target_does_save);
3684 do_cleanups (back_to);
3687 /* Tell the target what to do with an ongoing tracing run if GDB
3688 disconnects for some reason. */
3691 set_disconnected_tracing (char *args, int from_tty,
3692 struct cmd_list_element *c)
3694 target_set_disconnected_tracing (disconnected_tracing);
3698 set_circular_trace_buffer (char *args, int from_tty,
3699 struct cmd_list_element *c)
3701 target_set_circular_trace_buffer (circular_trace_buffer);
3705 set_trace_buffer_size (char *args, int from_tty,
3706 struct cmd_list_element *c)
3708 target_set_trace_buffer_size (trace_buffer_size);
3712 set_trace_user (char *args, int from_tty,
3713 struct cmd_list_element *c)
3717 ret = target_set_trace_notes (trace_user, NULL, NULL);
3720 warning (_("Target does not support trace notes, user ignored"));
3724 set_trace_notes (char *args, int from_tty,
3725 struct cmd_list_element *c)
3729 ret = target_set_trace_notes (NULL, trace_notes, NULL);
3732 warning (_("Target does not support trace notes, note ignored"));
3736 set_trace_stop_notes (char *args, int from_tty,
3737 struct cmd_list_element *c)
3741 ret = target_set_trace_notes (NULL, NULL, trace_stop_notes);
3744 warning (_("Target does not support trace notes, stop note ignored"));
3747 /* Convert the memory pointed to by mem into hex, placing result in buf.
3748 * Return a pointer to the last char put in buf (null)
3749 * "stolen" from sparc-stub.c
3752 static const char hexchars[] = "0123456789abcdef";
3755 mem2hex (gdb_byte *mem, char *buf, int count)
3763 *buf++ = hexchars[ch >> 4];
3764 *buf++ = hexchars[ch & 0xf];
3773 get_traceframe_number (void)
3775 return traceframe_number;
3779 get_tracepoint_number (void)
3781 return tracepoint_number;
3784 /* Make the traceframe NUM be the current trace frame. Does nothing
3785 if NUM is already current. */
3788 set_current_traceframe (int num)
3792 if (traceframe_number == num)
3794 /* Nothing to do. */
3798 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
3801 warning (_("could not change traceframe"));
3803 set_traceframe_num (newnum);
3805 /* Changing the traceframe changes our view of registers and of the
3807 registers_changed ();
3809 clear_traceframe_info ();
3812 /* Make the traceframe NUM be the current trace frame, and do nothing
3816 set_traceframe_number (int num)
3818 traceframe_number = num;
3821 /* A cleanup used when switching away and back from tfind mode. */
3823 struct current_traceframe_cleanup
3825 /* The traceframe we were inspecting. */
3826 int traceframe_number;
3830 do_restore_current_traceframe_cleanup (void *arg)
3832 struct current_traceframe_cleanup *old = arg;
3834 set_current_traceframe (old->traceframe_number);
3838 restore_current_traceframe_cleanup_dtor (void *arg)
3840 struct current_traceframe_cleanup *old = arg;
3846 make_cleanup_restore_current_traceframe (void)
3848 struct current_traceframe_cleanup *old;
3850 old = xmalloc (sizeof (struct current_traceframe_cleanup));
3851 old->traceframe_number = traceframe_number;
3853 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
3854 restore_current_traceframe_cleanup_dtor);
3858 make_cleanup_restore_traceframe_number (void)
3860 return make_cleanup_restore_integer (&traceframe_number);
3863 /* Given a number and address, return an uploaded tracepoint with that
3864 number, creating if necessary. */
3866 struct uploaded_tp *
3867 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
3869 struct uploaded_tp *utp;
3871 for (utp = *utpp; utp; utp = utp->next)
3872 if (utp->number == num && utp->addr == addr)
3874 utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
3875 memset (utp, 0, sizeof (struct uploaded_tp));
3878 utp->actions = NULL;
3879 utp->step_actions = NULL;
3880 utp->cmd_strings = NULL;
3887 free_uploaded_tps (struct uploaded_tp **utpp)
3889 struct uploaded_tp *next_one;
3893 next_one = (*utpp)->next;
3899 /* Given a number and address, return an uploaded tracepoint with that
3900 number, creating if necessary. */
3902 struct uploaded_tsv *
3903 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
3905 struct uploaded_tsv *utsv;
3907 for (utsv = *utsvp; utsv; utsv = utsv->next)
3908 if (utsv->number == num)
3910 utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
3911 memset (utsv, 0, sizeof (struct uploaded_tsv));
3913 utsv->next = *utsvp;
3919 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3921 struct uploaded_tsv *next_one;
3925 next_one = (*utsvp)->next;
3931 /* FIXME this function is heuristic and will miss the cases where the
3932 conditional is semantically identical but differs in whitespace,
3933 such as "x == 0" vs "x==0". */
3936 cond_string_is_same (char *str1, char *str2)
3938 if (str1 == NULL || str2 == NULL)
3939 return (str1 == str2);
3941 return (strcmp (str1, str2) == 0);
3944 /* Look for an existing tracepoint that seems similar enough to the
3945 uploaded one. Enablement isn't compared, because the user can
3946 toggle that freely, and may have done so in anticipation of the
3947 next trace run. Return the location of matched tracepoint. */
3949 static struct bp_location *
3950 find_matching_tracepoint_location (struct uploaded_tp *utp)
3952 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
3954 struct breakpoint *b;
3955 struct bp_location *loc;
3957 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
3959 struct tracepoint *t = (struct tracepoint *) b;
3961 if (b->type == utp->type
3962 && t->step_count == utp->step
3963 && t->pass_count == utp->pass
3964 && cond_string_is_same (t->base.cond_string, utp->cond_string)
3965 /* FIXME also test actions. */
3968 /* Scan the locations for an address match. */
3969 for (loc = b->loc; loc; loc = loc->next)
3971 if (loc->address == utp->addr)
3979 /* Given a list of tracepoints uploaded from a target, attempt to
3980 match them up with existing tracepoints, and create new ones if not
3984 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3986 struct uploaded_tp *utp;
3987 /* A set of tracepoints which are modified. */
3988 VEC(breakpoint_p) *modified_tp = NULL;
3990 struct breakpoint *b;
3992 /* Look for GDB tracepoints that match up with our uploaded versions. */
3993 for (utp = *uploaded_tps; utp; utp = utp->next)
3995 struct bp_location *loc;
3996 struct tracepoint *t;
3998 loc = find_matching_tracepoint_location (utp);
4003 /* Mark this location as already inserted. */
4005 t = (struct tracepoint *) loc->owner;
4006 printf_filtered (_("Assuming tracepoint %d is same "
4007 "as target's tracepoint %d at %s.\n"),
4008 loc->owner->number, utp->number,
4009 paddress (loc->gdbarch, utp->addr));
4011 /* The tracepoint LOC->owner was modified (the location LOC
4012 was marked as inserted in the target). Save it in
4013 MODIFIED_TP if not there yet. The 'breakpoint-modified'
4014 observers will be notified later once for each tracepoint
4015 saved in MODIFIED_TP. */
4017 VEC_iterate (breakpoint_p, modified_tp, ix, b);
4019 if (b == loc->owner)
4025 VEC_safe_push (breakpoint_p, modified_tp, loc->owner);
4029 t = create_tracepoint_from_upload (utp);
4031 printf_filtered (_("Created tracepoint %d for "
4032 "target's tracepoint %d at %s.\n"),
4033 t->base.number, utp->number,
4034 paddress (get_current_arch (), utp->addr));
4036 printf_filtered (_("Failed to create tracepoint for target's "
4037 "tracepoint %d at %s, skipping it.\n"),
4039 paddress (get_current_arch (), utp->addr));
4041 /* Whether found or created, record the number used by the
4042 target, to help with mapping target tracepoints back to their
4043 counterparts here. */
4045 t->number_on_target = utp->number;
4048 /* Notify 'breakpoint-modified' observer that at least one of B's
4049 locations was changed. */
4050 for (ix = 0; VEC_iterate (breakpoint_p, modified_tp, ix, b); ix++)
4051 observer_notify_breakpoint_modified (b);
4053 VEC_free (breakpoint_p, modified_tp);
4054 free_uploaded_tps (uploaded_tps);
4057 /* Trace state variables don't have much to identify them beyond their
4058 name, so just use that to detect matches. */
4060 static struct trace_state_variable *
4061 find_matching_tsv (struct uploaded_tsv *utsv)
4066 return find_trace_state_variable (utsv->name);
4069 static struct trace_state_variable *
4070 create_tsv_from_upload (struct uploaded_tsv *utsv)
4072 const char *namebase;
4075 struct trace_state_variable *tsv;
4076 struct cleanup *old_chain;
4080 namebase = utsv->name;
4081 buf = xstrprintf ("%s", namebase);
4086 buf = xstrprintf ("%s_%d", namebase, try_num++);
4089 /* Fish for a name that is not in use. */
4090 /* (should check against all internal vars?) */
4091 while (find_trace_state_variable (buf))
4094 buf = xstrprintf ("%s_%d", namebase, try_num++);
4097 old_chain = make_cleanup (xfree, buf);
4099 /* We have an available name, create the variable. */
4100 tsv = create_trace_state_variable (buf);
4101 tsv->initial_value = utsv->initial_value;
4102 tsv->builtin = utsv->builtin;
4104 observer_notify_tsv_created (tsv);
4106 do_cleanups (old_chain);
4111 /* Given a list of uploaded trace state variables, try to match them
4112 up with existing variables, or create additional ones. */
4115 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
4118 struct uploaded_tsv *utsv;
4119 struct trace_state_variable *tsv;
4122 /* Most likely some numbers will have to be reassigned as part of
4123 the merge, so clear them all in anticipation. */
4124 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
4127 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
4129 tsv = find_matching_tsv (utsv);
4133 printf_filtered (_("Assuming trace state variable $%s "
4134 "is same as target's variable %d.\n"),
4135 tsv->name, utsv->number);
4139 tsv = create_tsv_from_upload (utsv);
4141 printf_filtered (_("Created trace state variable "
4142 "$%s for target's variable %d.\n"),
4143 tsv->name, utsv->number);
4145 /* Give precedence to numberings that come from the target. */
4147 tsv->number = utsv->number;
4150 /* Renumber everything that didn't get a target-assigned number. */
4152 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
4153 if (tsv->number > highest)
4154 highest = tsv->number;
4157 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
4158 if (tsv->number == 0)
4159 tsv->number = highest++;
4161 free_uploaded_tsvs (uploaded_tsvs);
4164 /* target tfile command */
4166 static struct target_ops tfile_ops;
4168 /* Fill in tfile_ops with its defined operations and properties. */
4170 #define TRACE_HEADER_SIZE 8
4172 static char *trace_filename;
4173 static int trace_fd = -1;
4174 static off_t trace_frames_offset;
4175 static off_t cur_offset;
4176 static int cur_data_size;
4177 int trace_regblock_size;
4179 static void tfile_interp_line (char *line,
4180 struct uploaded_tp **utpp,
4181 struct uploaded_tsv **utsvp);
4183 /* Read SIZE bytes into READBUF from the trace frame, starting at
4184 TRACE_FD's current position. Note that this call `read'
4185 underneath, hence it advances the file's seek position. Throws an
4186 error if the `read' syscall fails, or less than SIZE bytes are
4190 tfile_read (gdb_byte *readbuf, int size)
4194 gotten = read (trace_fd, readbuf, size);
4196 perror_with_name (trace_filename);
4197 else if (gotten < size)
4198 error (_("Premature end of file while reading trace file"));
4202 tfile_open (char *filename, int from_tty)
4204 volatile struct gdb_exception ex;
4206 struct cleanup *old_chain;
4209 char header[TRACE_HEADER_SIZE];
4210 char linebuf[1000]; /* Should be max remote packet size or so. */
4213 struct trace_status *ts;
4214 struct uploaded_tp *uploaded_tps = NULL;
4215 struct uploaded_tsv *uploaded_tsvs = NULL;
4217 target_preopen (from_tty);
4219 error (_("No trace file specified."));
4221 filename = tilde_expand (filename);
4222 if (!IS_ABSOLUTE_PATH(filename))
4224 temp = concat (current_directory, "/", filename, (char *) NULL);
4229 old_chain = make_cleanup (xfree, filename);
4231 flags = O_BINARY | O_LARGEFILE;
4233 scratch_chan = gdb_open_cloexec (filename, flags, 0);
4234 if (scratch_chan < 0)
4235 perror_with_name (filename);
4237 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
4239 discard_cleanups (old_chain); /* Don't free filename any more. */
4240 unpush_target (&tfile_ops);
4242 trace_filename = xstrdup (filename);
4243 trace_fd = scratch_chan;
4246 /* Read the file header and test for validity. */
4247 tfile_read ((gdb_byte *) &header, TRACE_HEADER_SIZE);
4249 bytes += TRACE_HEADER_SIZE;
4250 if (!(header[0] == 0x7f
4251 && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
4252 error (_("File is not a valid trace file."));
4254 push_target (&tfile_ops);
4256 trace_regblock_size = 0;
4257 ts = current_trace_status ();
4258 /* We know we're working with a file. Record its name. */
4259 ts->filename = trace_filename;
4260 /* Set defaults in case there is no status line. */
4261 ts->running_known = 0;
4262 ts->stop_reason = trace_stop_reason_unknown;
4263 ts->traceframe_count = -1;
4264 ts->buffer_free = 0;
4265 ts->disconnected_tracing = 0;
4266 ts->circular_buffer = 0;
4268 TRY_CATCH (ex, RETURN_MASK_ALL)
4270 /* Read through a section of newline-terminated lines that
4271 define things like tracepoints. */
4275 tfile_read (&byte, 1);
4280 /* Empty line marks end of the definition section. */
4285 tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
4288 linebuf[i++] = byte;
4290 error (_("Excessively long lines in trace file"));
4293 /* Record the starting offset of the binary trace data. */
4294 trace_frames_offset = bytes;
4296 /* If we don't have a blocksize, we can't interpret the
4298 if (trace_regblock_size == 0)
4299 error (_("No register block size recorded in trace file"));
4303 /* Pop the partially set up target. */
4305 throw_exception (ex);
4308 if (ts->traceframe_count <= 0)
4309 warning (_("No traceframes present in this file."));
4311 /* Add the file's tracepoints and variables into the current mix. */
4313 /* Get trace state variables first, they may be checked when parsing
4314 uploaded commands. */
4315 merge_uploaded_trace_state_variables (&uploaded_tsvs);
4317 merge_uploaded_tracepoints (&uploaded_tps);
4320 /* Interpret the given line from the definitions part of the trace
4324 tfile_interp_line (char *line, struct uploaded_tp **utpp,
4325 struct uploaded_tsv **utsvp)
4329 if (strncmp (p, "R ", strlen ("R ")) == 0)
4332 trace_regblock_size = strtol (p, &p, 16);
4334 else if (strncmp (p, "status ", strlen ("status ")) == 0)
4336 p += strlen ("status ");
4337 parse_trace_status (p, current_trace_status ());
4339 else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
4341 p += strlen ("tp ");
4342 parse_tracepoint_definition (p, utpp);
4344 else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
4346 p += strlen ("tsv ");
4347 parse_tsv_definition (p, utsvp);
4350 warning (_("Ignoring trace file definition \"%s\""), line);
4353 /* Parse the part of trace status syntax that is shared between
4354 the remote protocol and the trace file reader. */
4357 parse_trace_status (char *line, struct trace_status *ts)
4359 char *p = line, *p1, *p2, *p3, *p_temp;
4363 ts->running_known = 1;
4364 ts->running = (*p++ == '1');
4365 ts->stop_reason = trace_stop_reason_unknown;
4366 xfree (ts->stop_desc);
4367 ts->stop_desc = NULL;
4368 ts->traceframe_count = -1;
4369 ts->traceframes_created = -1;
4370 ts->buffer_free = -1;
4371 ts->buffer_size = -1;
4372 ts->disconnected_tracing = 0;
4373 ts->circular_buffer = 0;
4374 xfree (ts->user_name);
4375 ts->user_name = NULL;
4378 ts->start_time = ts->stop_time = 0;
4382 p1 = strchr (p, ':');
4384 error (_("Malformed trace status, at %s\n\
4385 Status line: '%s'\n"), p, line);
4386 p3 = strchr (p, ';');
4388 p3 = p + strlen (p);
4389 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
4391 p = unpack_varlen_hex (++p1, &val);
4392 ts->stop_reason = trace_buffer_full;
4394 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
4396 p = unpack_varlen_hex (++p1, &val);
4397 ts->stop_reason = trace_never_run;
4399 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
4402 p = unpack_varlen_hex (++p1, &val);
4403 ts->stop_reason = tracepoint_passcount;
4404 ts->stopping_tracepoint = val;
4406 else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
4408 p2 = strchr (++p1, ':');
4416 ts->stop_desc = xmalloc (strlen (line));
4417 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
4418 ts->stop_desc[end] = '\0';
4421 ts->stop_desc = xstrdup ("");
4423 p = unpack_varlen_hex (++p2, &val);
4424 ts->stop_reason = tstop_command;
4426 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
4428 p = unpack_varlen_hex (++p1, &val);
4429 ts->stop_reason = trace_disconnected;
4431 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
4433 p2 = strchr (++p1, ':');
4436 ts->stop_desc = xmalloc ((p2 - p1) / 2 + 1);
4437 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
4438 ts->stop_desc[end] = '\0';
4441 ts->stop_desc = xstrdup ("");
4443 p = unpack_varlen_hex (++p2, &val);
4444 ts->stopping_tracepoint = val;
4445 ts->stop_reason = tracepoint_error;
4447 else if (strncmp (p, "tframes", p1 - p) == 0)
4449 p = unpack_varlen_hex (++p1, &val);
4450 ts->traceframe_count = val;
4452 else if (strncmp (p, "tcreated", p1 - p) == 0)
4454 p = unpack_varlen_hex (++p1, &val);
4455 ts->traceframes_created = val;
4457 else if (strncmp (p, "tfree", p1 - p) == 0)
4459 p = unpack_varlen_hex (++p1, &val);
4460 ts->buffer_free = val;
4462 else if (strncmp (p, "tsize", p1 - p) == 0)
4464 p = unpack_varlen_hex (++p1, &val);
4465 ts->buffer_size = val;
4467 else if (strncmp (p, "disconn", p1 - p) == 0)
4469 p = unpack_varlen_hex (++p1, &val);
4470 ts->disconnected_tracing = val;
4472 else if (strncmp (p, "circular", p1 - p) == 0)
4474 p = unpack_varlen_hex (++p1, &val);
4475 ts->circular_buffer = val;
4477 else if (strncmp (p, "starttime", p1 - p) == 0)
4479 p = unpack_varlen_hex (++p1, &val);
4480 ts->start_time = val;
4482 else if (strncmp (p, "stoptime", p1 - p) == 0)
4484 p = unpack_varlen_hex (++p1, &val);
4485 ts->stop_time = val;
4487 else if (strncmp (p, "username", p1 - p) == 0)
4490 ts->user_name = xmalloc (strlen (p) / 2);
4491 end = hex2bin (p1, (gdb_byte *) ts->user_name, (p3 - p1) / 2);
4492 ts->user_name[end] = '\0';
4495 else if (strncmp (p, "notes", p1 - p) == 0)
4498 ts->notes = xmalloc (strlen (p) / 2);
4499 end = hex2bin (p1, (gdb_byte *) ts->notes, (p3 - p1) / 2);
4500 ts->notes[end] = '\0';
4505 /* Silently skip unknown optional info. */
4506 p_temp = strchr (p1 + 1, ';');
4510 /* Must be at the end. */
4517 parse_tracepoint_status (char *p, struct breakpoint *bp,
4518 struct uploaded_tp *utp)
4521 struct tracepoint *tp = (struct tracepoint *) bp;
4523 p = unpack_varlen_hex (p, &uval);
4525 tp->base.hit_count += uval;
4527 utp->hit_count += uval;
4528 p = unpack_varlen_hex (p + 1, &uval);
4530 tp->traceframe_usage += uval;
4532 utp->traceframe_usage += uval;
4533 /* Ignore any extra, allowing for future extensions. */
4536 /* Given a line of text defining a part of a tracepoint, parse it into
4537 an "uploaded tracepoint". */
4540 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
4544 ULONGEST num, addr, step, pass, orig_size, xlen, start;
4547 char *cond, *srctype, *buf;
4548 struct uploaded_tp *utp = NULL;
4551 /* Both tracepoint and action definitions start with the same number
4552 and address sequence. */
4554 p = unpack_varlen_hex (p, &num);
4555 p++; /* skip a colon */
4556 p = unpack_varlen_hex (p, &addr);
4557 p++; /* skip a colon */
4560 enabled = (*p++ == 'E');
4561 p++; /* skip a colon */
4562 p = unpack_varlen_hex (p, &step);
4563 p++; /* skip a colon */
4564 p = unpack_varlen_hex (p, &pass);
4565 type = bp_tracepoint;
4567 /* Thumb through optional fields. */
4570 p++; /* skip a colon */
4573 type = bp_fast_tracepoint;
4575 p = unpack_varlen_hex (p, &orig_size);
4579 type = bp_static_tracepoint;
4585 p = unpack_varlen_hex (p, &xlen);
4586 p++; /* skip a comma */
4587 cond = (char *) xmalloc (2 * xlen + 1);
4588 strncpy (cond, p, 2 * xlen);
4589 cond[2 * xlen] = '\0';
4593 warning (_("Unrecognized char '%c' in tracepoint "
4594 "definition, skipping rest"), *p);
4596 utp = get_uploaded_tp (num, addr, utpp);
4598 utp->enabled = enabled;
4603 else if (piece == 'A')
4605 utp = get_uploaded_tp (num, addr, utpp);
4606 VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
4608 else if (piece == 'S')
4610 utp = get_uploaded_tp (num, addr, utpp);
4611 VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
4613 else if (piece == 'Z')
4615 /* Parse a chunk of source form definition. */
4616 utp = get_uploaded_tp (num, addr, utpp);
4618 p = strchr (p, ':');
4619 p++; /* skip a colon */
4620 p = unpack_varlen_hex (p, &start);
4621 p++; /* skip a colon */
4622 p = unpack_varlen_hex (p, &xlen);
4623 p++; /* skip a colon */
4625 buf = alloca (strlen (line));
4627 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
4630 if (strncmp (srctype, "at:", strlen ("at:")) == 0)
4631 utp->at_string = xstrdup (buf);
4632 else if (strncmp (srctype, "cond:", strlen ("cond:")) == 0)
4633 utp->cond_string = xstrdup (buf);
4634 else if (strncmp (srctype, "cmd:", strlen ("cmd:")) == 0)
4635 VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
4637 else if (piece == 'V')
4639 utp = get_uploaded_tp (num, addr, utpp);
4641 parse_tracepoint_status (p, NULL, utp);
4645 /* Don't error out, the target might be sending us optional
4646 info that we don't care about. */
4647 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
4651 /* Convert a textual description of a trace state variable into an
4655 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
4658 ULONGEST num, initval, builtin;
4660 struct uploaded_tsv *utsv = NULL;
4662 buf = alloca (strlen (line));
4665 p = unpack_varlen_hex (p, &num);
4666 p++; /* skip a colon */
4667 p = unpack_varlen_hex (p, &initval);
4668 p++; /* skip a colon */
4669 p = unpack_varlen_hex (p, &builtin);
4670 p++; /* skip a colon */
4671 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
4674 utsv = get_uploaded_tsv (num, utsvp);
4675 utsv->initial_value = initval;
4676 utsv->builtin = builtin;
4677 utsv->name = xstrdup (buf);
4680 /* Close the trace file and generally clean up. */
4692 xfree (trace_filename);
4693 trace_filename = NULL;
4695 trace_reset_local_state ();
4699 tfile_files_info (struct target_ops *t)
4701 printf_filtered ("\t`%s'\n", trace_filename);
4704 /* The trace status for a file is that tracing can never be run. */
4707 tfile_get_trace_status (struct trace_status *ts)
4709 /* Other bits of trace status were collected as part of opening the
4710 trace files, so nothing to do here. */
4716 tfile_get_tracepoint_status (struct breakpoint *tp, struct uploaded_tp *utp)
4718 /* Other bits of trace status were collected as part of opening the
4719 trace files, so nothing to do here. */
4722 /* Given the position of a traceframe in the file, figure out what
4723 address the frame was collected at. This would normally be the
4724 value of a collected PC register, but if not available, we
4728 tfile_get_traceframe_address (off_t tframe_offset)
4732 struct tracepoint *tp;
4733 off_t saved_offset = cur_offset;
4735 /* FIXME dig pc out of collected registers. */
4737 /* Fall back to using tracepoint address. */
4738 lseek (trace_fd, tframe_offset, SEEK_SET);
4739 tfile_read ((gdb_byte *) &tpnum, 2);
4740 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
4742 (target_gdbarch ()));
4744 tp = get_tracepoint_by_number_on_target (tpnum);
4745 /* FIXME this is a poor heuristic if multiple locations. */
4746 if (tp && tp->base.loc)
4747 addr = tp->base.loc->address;
4749 /* Restore our seek position. */
4750 cur_offset = saved_offset;
4751 lseek (trace_fd, cur_offset, SEEK_SET);
4755 /* Given a type of search and some parameters, scan the collection of
4756 traceframes in the file looking for a match. When found, return
4757 both the traceframe and tracepoint number, otherwise -1 for
4761 tfile_trace_find (enum trace_find_type type, int num,
4762 CORE_ADDR addr1, CORE_ADDR addr2, int *tpp)
4765 int tfnum = 0, found = 0;
4766 unsigned int data_size;
4767 struct tracepoint *tp;
4768 off_t offset, tframe_offset;
4778 lseek (trace_fd, trace_frames_offset, SEEK_SET);
4779 offset = trace_frames_offset;
4782 tframe_offset = offset;
4783 tfile_read ((gdb_byte *) &tpnum, 2);
4784 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
4786 (target_gdbarch ()));
4790 tfile_read ((gdb_byte *) &data_size, 4);
4791 data_size = (unsigned int) extract_unsigned_integer
4792 ((gdb_byte *) &data_size, 4,
4793 gdbarch_byte_order (target_gdbarch ()));
4796 if (type == tfind_number)
4798 /* Looking for a specific trace frame. */
4804 /* Start from the _next_ trace frame. */
4805 if (tfnum > traceframe_number)
4810 tfaddr = tfile_get_traceframe_address (tframe_offset);
4811 if (tfaddr == addr1)
4815 tp = get_tracepoint (num);
4816 if (tp && tpnum == tp->number_on_target)
4820 tfaddr = tfile_get_traceframe_address (tframe_offset);
4821 if (addr1 <= tfaddr && tfaddr <= addr2)
4825 tfaddr = tfile_get_traceframe_address (tframe_offset);
4826 if (!(addr1 <= tfaddr && tfaddr <= addr2))
4830 internal_error (__FILE__, __LINE__, _("unknown tfind type"));
4839 cur_offset = offset;
4840 cur_data_size = data_size;
4844 /* Skip past the traceframe's data. */
4845 lseek (trace_fd, data_size, SEEK_CUR);
4846 offset += data_size;
4847 /* Update our own count of traceframes. */
4850 /* Did not find what we were looking for. */
4856 /* Prototype of the callback passed to tframe_walk_blocks. */
4857 typedef int (*walk_blocks_callback_func) (char blocktype, void *data);
4859 /* Callback for traceframe_walk_blocks, used to find a given block
4860 type in a traceframe. */
4863 match_blocktype (char blocktype, void *data)
4865 char *wantedp = data;
4867 if (*wantedp == blocktype)
4873 /* Walk over all traceframe block starting at POS offset from
4874 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4875 unmodified. If CALLBACK returns true, this returns the position in
4876 the traceframe where the block is found, relative to the start of
4877 the traceframe (cur_offset). Returns -1 if no callback call
4878 returned true, indicating that all blocks have been walked. */
4881 traceframe_walk_blocks (walk_blocks_callback_func callback,
4882 int pos, void *data)
4884 /* Iterate through a traceframe's blocks, looking for a block of the
4887 lseek (trace_fd, cur_offset + pos, SEEK_SET);
4888 while (pos < cur_data_size)
4890 unsigned short mlen;
4893 tfile_read ((gdb_byte *) &block_type, 1);
4897 if ((*callback) (block_type, data))
4903 lseek (trace_fd, cur_offset + pos + trace_regblock_size, SEEK_SET);
4904 pos += trace_regblock_size;
4907 lseek (trace_fd, cur_offset + pos + 8, SEEK_SET);
4908 tfile_read ((gdb_byte *) &mlen, 2);
4909 mlen = (unsigned short)
4910 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
4912 (target_gdbarch ()));
4913 lseek (trace_fd, mlen, SEEK_CUR);
4914 pos += (8 + 2 + mlen);
4917 lseek (trace_fd, cur_offset + pos + 4 + 8, SEEK_SET);
4921 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4922 block_type, block_type);
4930 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4931 position offset of a block of type TYPE_WANTED in the current trace
4932 frame, starting at POS. Returns -1 if no such block was found. */
4935 traceframe_find_block_type (char type_wanted, int pos)
4937 return traceframe_walk_blocks (match_blocktype, pos, &type_wanted);
4940 /* Look for a block of saved registers in the traceframe, and get the
4941 requested register from it. */
4944 tfile_fetch_registers (struct target_ops *ops,
4945 struct regcache *regcache, int regno)
4947 struct gdbarch *gdbarch = get_regcache_arch (regcache);
4948 int offset, regn, regsize, pc_regno;
4951 /* An uninitialized reg size says we're not going to be
4952 successful at getting register blocks. */
4953 if (!trace_regblock_size)
4956 regs = alloca (trace_regblock_size);
4958 if (traceframe_find_block_type ('R', 0) >= 0)
4960 tfile_read (regs, trace_regblock_size);
4962 /* Assume the block is laid out in GDB register number order,
4963 each register with the size that it has in GDB. */
4965 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
4967 regsize = register_size (gdbarch, regn);
4968 /* Make sure we stay within block bounds. */
4969 if (offset + regsize >= trace_regblock_size)
4971 if (regcache_register_status (regcache, regn) == REG_UNKNOWN)
4975 regcache_raw_supply (regcache, regno, regs + offset);
4978 else if (regno == -1)
4980 regcache_raw_supply (regcache, regn, regs + offset);
4988 /* We get here if no register data has been found. Mark registers
4990 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
4991 regcache_raw_supply (regcache, regn, NULL);
4993 /* We can often usefully guess that the PC is going to be the same
4994 as the address of the tracepoint. */
4995 pc_regno = gdbarch_pc_regnum (gdbarch);
4996 if (pc_regno >= 0 && (regno == -1 || regno == pc_regno))
4998 struct tracepoint *tp = get_tracepoint (tracepoint_number);
5000 if (tp && tp->base.loc)
5002 /* But don't try to guess if tracepoint is multi-location... */
5003 if (tp->base.loc->next)
5005 warning (_("Tracepoint %d has multiple "
5006 "locations, cannot infer $pc"),
5010 /* ... or does while-stepping. */
5011 if (tp->step_count > 0)
5013 warning (_("Tracepoint %d does while-stepping, "
5014 "cannot infer $pc"),
5019 store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
5020 gdbarch_byte_order (gdbarch),
5021 tp->base.loc->address);
5022 regcache_raw_supply (regcache, pc_regno, regs);
5028 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
5029 const char *annex, gdb_byte *readbuf,
5030 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
5032 /* We're only doing regular memory for now. */
5033 if (object != TARGET_OBJECT_MEMORY)
5036 if (readbuf == NULL)
5037 error (_("tfile_xfer_partial: trace file is read-only"));
5039 if (traceframe_number != -1)
5043 /* Iterate through the traceframe's blocks, looking for
5045 while ((pos = traceframe_find_block_type ('M', pos)) >= 0)
5047 ULONGEST maddr, amt;
5048 unsigned short mlen;
5049 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
5051 tfile_read ((gdb_byte *) &maddr, 8);
5052 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
5054 tfile_read ((gdb_byte *) &mlen, 2);
5055 mlen = (unsigned short)
5056 extract_unsigned_integer ((gdb_byte *) &mlen, 2, byte_order);
5058 /* If the block includes the first part of the desired
5059 range, return as much it has; GDB will re-request the
5060 remainder, which might be in a different block of this
5062 if (maddr <= offset && offset < (maddr + mlen))
5064 amt = (maddr + mlen) - offset;
5068 if (maddr != offset)
5069 lseek (trace_fd, offset - maddr, SEEK_CUR);
5070 tfile_read (readbuf, amt);
5074 /* Skip over this block. */
5075 pos += (8 + 2 + mlen);
5079 /* It's unduly pedantic to refuse to look at the executable for
5080 read-only pieces; so do the equivalent of readonly regions aka
5082 /* FIXME account for relocation at some point. */
5089 for (s = exec_bfd->sections; s; s = s->next)
5091 if ((s->flags & SEC_LOAD) == 0
5092 || (s->flags & SEC_READONLY) == 0)
5096 size = bfd_get_section_size (s);
5097 if (vma <= offset && offset < (vma + size))
5101 amt = (vma + size) - offset;
5105 amt = bfd_get_section_contents (exec_bfd, s,
5106 readbuf, offset - vma, amt);
5112 /* Indicate failure to find the requested memory block. */
5116 /* Iterate through the blocks of a trace frame, looking for a 'V'
5117 block with a matching tsv number. */
5120 tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
5125 /* Iterate over blocks in current frame and find the last 'V'
5126 block in which tsv number is TSVNUM. In one trace frame, there
5127 may be multiple 'V' blocks created for a given trace variable,
5128 and the last matched 'V' block contains the updated value. */
5130 while ((pos = traceframe_find_block_type ('V', pos)) >= 0)
5134 tfile_read ((gdb_byte *) &vnum, 4);
5135 vnum = (int) extract_signed_integer ((gdb_byte *) &vnum, 4,
5137 (target_gdbarch ()));
5140 tfile_read ((gdb_byte *) val, 8);
5141 *val = extract_signed_integer ((gdb_byte *) val, 8,
5143 (target_gdbarch ()));
5153 tfile_has_all_memory (struct target_ops *ops)
5159 tfile_has_memory (struct target_ops *ops)
5165 tfile_has_stack (struct target_ops *ops)
5167 return traceframe_number != -1;
5171 tfile_has_registers (struct target_ops *ops)
5173 return traceframe_number != -1;
5176 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
5177 object for the tfile target's current traceframe. */
5180 build_traceframe_info (char blocktype, void *data)
5182 struct traceframe_info *info = data;
5188 struct mem_range *r;
5190 unsigned short mlen;
5192 tfile_read ((gdb_byte *) &maddr, 8);
5193 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
5195 (target_gdbarch ()));
5196 tfile_read ((gdb_byte *) &mlen, 2);
5197 mlen = (unsigned short)
5198 extract_unsigned_integer ((gdb_byte *) &mlen,
5199 2, gdbarch_byte_order
5200 (target_gdbarch ()));
5202 r = VEC_safe_push (mem_range_s, info->memory, NULL);
5215 warning (_("Unhandled trace block type (%d) '%c ' "
5216 "while building trace frame info."),
5217 blocktype, blocktype);
5224 static struct traceframe_info *
5225 tfile_traceframe_info (void)
5227 struct traceframe_info *info = XCNEW (struct traceframe_info);
5229 traceframe_walk_blocks (build_traceframe_info, 0, info);
5234 init_tfile_ops (void)
5236 tfile_ops.to_shortname = "tfile";
5237 tfile_ops.to_longname = "Local trace dump file";
5239 = "Use a trace file as a target. Specify the filename of the trace file.";
5240 tfile_ops.to_open = tfile_open;
5241 tfile_ops.to_close = tfile_close;
5242 tfile_ops.to_fetch_registers = tfile_fetch_registers;
5243 tfile_ops.to_xfer_partial = tfile_xfer_partial;
5244 tfile_ops.to_files_info = tfile_files_info;
5245 tfile_ops.to_get_trace_status = tfile_get_trace_status;
5246 tfile_ops.to_get_tracepoint_status = tfile_get_tracepoint_status;
5247 tfile_ops.to_trace_find = tfile_trace_find;
5248 tfile_ops.to_get_trace_state_variable_value
5249 = tfile_get_trace_state_variable_value;
5250 tfile_ops.to_stratum = process_stratum;
5251 tfile_ops.to_has_all_memory = tfile_has_all_memory;
5252 tfile_ops.to_has_memory = tfile_has_memory;
5253 tfile_ops.to_has_stack = tfile_has_stack;
5254 tfile_ops.to_has_registers = tfile_has_registers;
5255 tfile_ops.to_traceframe_info = tfile_traceframe_info;
5256 tfile_ops.to_magic = OPS_MAGIC;
5260 free_current_marker (void *arg)
5262 struct static_tracepoint_marker **marker_p = arg;
5264 if (*marker_p != NULL)
5266 release_static_tracepoint_marker (*marker_p);
5273 /* Given a line of text defining a static tracepoint marker, parse it
5274 into a "static tracepoint marker" object. Throws an error is
5275 parsing fails. If PP is non-null, it points to one past the end of
5276 the parsed marker definition. */
5279 parse_static_tracepoint_marker_definition (char *line, char **pp,
5280 struct static_tracepoint_marker *marker)
5287 p = unpack_varlen_hex (p, &addr);
5288 p++; /* skip a colon */
5290 marker->gdbarch = target_gdbarch ();
5291 marker->address = (CORE_ADDR) addr;
5293 endp = strchr (p, ':');
5295 error (_("bad marker definition: %s"), line);
5297 marker->str_id = xmalloc (endp - p + 1);
5298 end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
5299 marker->str_id[end] = '\0';
5302 p++; /* skip a colon */
5304 marker->extra = xmalloc (strlen (p) + 1);
5305 end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
5306 marker->extra[end] = '\0';
5312 /* Release a static tracepoint marker's contents. Note that the
5313 object itself isn't released here. There objects are usually on
5317 release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
5319 xfree (marker->str_id);
5320 marker->str_id = NULL;
5323 /* Print MARKER to gdb_stdout. */
5326 print_one_static_tracepoint_marker (int count,
5327 struct static_tracepoint_marker *marker)
5329 struct command_line *l;
5332 char wrap_indent[80];
5333 char extra_field_indent[80];
5334 struct ui_out *uiout = current_uiout;
5335 struct cleanup *bkpt_chain;
5336 VEC(breakpoint_p) *tracepoints;
5338 struct symtab_and_line sal;
5342 sal.pc = marker->address;
5344 tracepoints = static_tracepoints_here (marker->address);
5346 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "marker");
5348 /* A counter field to help readability. This is not a stable
5350 ui_out_field_int (uiout, "count", count);
5352 ui_out_field_string (uiout, "marker-id", marker->str_id);
5354 ui_out_field_fmt (uiout, "enabled", "%c",
5355 !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
5356 ui_out_spaces (uiout, 2);
5358 strcpy (wrap_indent, " ");
5360 if (gdbarch_addr_bit (marker->gdbarch) <= 32)
5361 strcat (wrap_indent, " ");
5363 strcat (wrap_indent, " ");
5365 strcpy (extra_field_indent, " ");
5367 ui_out_field_core_addr (uiout, "addr", marker->gdbarch, marker->address);
5369 sal = find_pc_line (marker->address, 0);
5370 sym = find_pc_sect_function (marker->address, NULL);
5373 ui_out_text (uiout, "in ");
5374 ui_out_field_string (uiout, "func",
5375 SYMBOL_PRINT_NAME (sym));
5376 ui_out_wrap_hint (uiout, wrap_indent);
5377 ui_out_text (uiout, " at ");
5380 ui_out_field_skip (uiout, "func");
5382 if (sal.symtab != NULL)
5384 ui_out_field_string (uiout, "file",
5385 symtab_to_filename_for_display (sal.symtab));
5386 ui_out_text (uiout, ":");
5388 if (ui_out_is_mi_like_p (uiout))
5390 const char *fullname = symtab_to_fullname (sal.symtab);
5392 ui_out_field_string (uiout, "fullname", fullname);
5395 ui_out_field_skip (uiout, "fullname");
5397 ui_out_field_int (uiout, "line", sal.line);
5401 ui_out_field_skip (uiout, "fullname");
5402 ui_out_field_skip (uiout, "line");
5405 ui_out_text (uiout, "\n");
5406 ui_out_text (uiout, extra_field_indent);
5407 ui_out_text (uiout, _("Data: \""));
5408 ui_out_field_string (uiout, "extra-data", marker->extra);
5409 ui_out_text (uiout, "\"\n");
5411 if (!VEC_empty (breakpoint_p, tracepoints))
5413 struct cleanup *cleanup_chain;
5415 struct breakpoint *b;
5417 cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
5420 ui_out_text (uiout, extra_field_indent);
5421 ui_out_text (uiout, _("Probed by static tracepoints: "));
5422 for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
5425 ui_out_text (uiout, ", ");
5426 ui_out_text (uiout, "#");
5427 ui_out_field_int (uiout, "tracepoint-id", b->number);
5430 do_cleanups (cleanup_chain);
5432 if (ui_out_is_mi_like_p (uiout))
5433 ui_out_field_int (uiout, "number-of-tracepoints",
5434 VEC_length(breakpoint_p, tracepoints));
5436 ui_out_text (uiout, "\n");
5438 VEC_free (breakpoint_p, tracepoints);
5440 do_cleanups (bkpt_chain);
5444 info_static_tracepoint_markers_command (char *arg, int from_tty)
5446 VEC(static_tracepoint_marker_p) *markers;
5447 struct cleanup *old_chain;
5448 struct static_tracepoint_marker *marker;
5449 struct ui_out *uiout = current_uiout;
5452 /* We don't have to check target_can_use_agent and agent's capability on
5453 static tracepoint here, in order to be compatible with older GDBserver.
5454 We don't check USE_AGENT is true or not, because static tracepoints
5455 don't work without in-process agent, so we don't bother users to type
5456 `set agent on' when to use static tracepoint. */
5459 = make_cleanup_ui_out_table_begin_end (uiout, 5, -1,
5460 "StaticTracepointMarkersTable");
5462 ui_out_table_header (uiout, 7, ui_left, "counter", "Cnt");
5464 ui_out_table_header (uiout, 40, ui_left, "marker-id", "ID");
5466 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
5467 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
5468 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");
5470 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
5471 ui_out_table_header (uiout, 40, ui_noalign, "what", "What");
5473 ui_out_table_body (uiout);
5475 markers = target_static_tracepoint_markers_by_strid (NULL);
5476 make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
5479 VEC_iterate (static_tracepoint_marker_p,
5480 markers, i, marker);
5483 print_one_static_tracepoint_marker (i + 1, marker);
5484 release_static_tracepoint_marker (marker);
5487 do_cleanups (old_chain);
5490 /* The $_sdata convenience variable is a bit special. We don't know
5491 for sure type of the value until we actually have a chance to fetch
5492 the data --- the size of the object depends on what has been
5493 collected. We solve this by making $_sdata be an internalvar that
5494 creates a new value on access. */
5496 /* Return a new value with the correct type for the sdata object of
5497 the current trace frame. Return a void value if there's no object
5500 static struct value *
5501 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var,
5507 /* We need to read the whole object before we know its size. */
5508 size = target_read_alloc (¤t_target,
5509 TARGET_OBJECT_STATIC_TRACE_DATA,
5516 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
5518 v = allocate_value (type);
5519 memcpy (value_contents_raw (v), buf, size);
5524 return allocate_value (builtin_type (gdbarch)->builtin_void);
5527 #if !defined(HAVE_LIBEXPAT)
5529 struct traceframe_info *
5530 parse_traceframe_info (const char *tframe_info)
5532 static int have_warned;
5537 warning (_("Can not parse XML trace frame info; XML support "
5538 "was disabled at compile time"));
5544 #else /* HAVE_LIBEXPAT */
5546 #include "xml-support.h"
5548 /* Handle the start of a <memory> element. */
5551 traceframe_info_start_memory (struct gdb_xml_parser *parser,
5552 const struct gdb_xml_element *element,
5553 void *user_data, VEC(gdb_xml_value_s) *attributes)
5555 struct traceframe_info *info = user_data;
5556 struct mem_range *r = VEC_safe_push (mem_range_s, info->memory, NULL);
5557 ULONGEST *start_p, *length_p;
5559 start_p = xml_find_attribute (attributes, "start")->value;
5560 length_p = xml_find_attribute (attributes, "length")->value;
5562 r->start = *start_p;
5563 r->length = *length_p;
5566 /* Discard the constructed trace frame info (if an error occurs). */
5569 free_result (void *p)
5571 struct traceframe_info *result = p;
5573 free_traceframe_info (result);
5576 /* The allowed elements and attributes for an XML memory map. */
5578 static const struct gdb_xml_attribute memory_attributes[] = {
5579 { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
5580 { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
5581 { NULL, GDB_XML_AF_NONE, NULL, NULL }
5584 static const struct gdb_xml_element traceframe_info_children[] = {
5585 { "memory", memory_attributes, NULL,
5586 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
5587 traceframe_info_start_memory, NULL },
5588 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
5591 static const struct gdb_xml_element traceframe_info_elements[] = {
5592 { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
5594 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
5597 /* Parse a traceframe-info XML document. */
5599 struct traceframe_info *
5600 parse_traceframe_info (const char *tframe_info)
5602 struct traceframe_info *result;
5603 struct cleanup *back_to;
5605 result = XCNEW (struct traceframe_info);
5606 back_to = make_cleanup (free_result, result);
5608 if (gdb_xml_parse_quick (_("trace frame info"),
5609 "traceframe-info.dtd", traceframe_info_elements,
5610 tframe_info, result) == 0)
5612 /* Parsed successfully, keep the result. */
5613 discard_cleanups (back_to);
5618 do_cleanups (back_to);
5622 #endif /* HAVE_LIBEXPAT */
5624 /* Returns the traceframe_info object for the current traceframe.
5625 This is where we avoid re-fetching the object from the target if we
5626 already have it cached. */
5628 static struct traceframe_info *
5629 get_traceframe_info (void)
5631 if (traceframe_info == NULL)
5632 traceframe_info = target_traceframe_info ();
5634 return traceframe_info;
5637 /* If the target supports the query, return in RESULT the set of
5638 collected memory in the current traceframe, found within the LEN
5639 bytes range starting at MEMADDR. Returns true if the target
5640 supports the query, otherwise returns false, and RESULT is left
5644 traceframe_available_memory (VEC(mem_range_s) **result,
5645 CORE_ADDR memaddr, ULONGEST len)
5647 struct traceframe_info *info = get_traceframe_info ();
5651 struct mem_range *r;
5656 for (i = 0; VEC_iterate (mem_range_s, info->memory, i, r); i++)
5657 if (mem_ranges_overlap (r->start, r->length, memaddr, len))
5659 ULONGEST lo1, hi1, lo2, hi2;
5660 struct mem_range *nr;
5663 hi1 = memaddr + len;
5666 hi2 = r->start + r->length;
5668 nr = VEC_safe_push (mem_range_s, *result, NULL);
5670 nr->start = max (lo1, lo2);
5671 nr->length = min (hi1, hi2) - nr->start;
5674 normalize_mem_ranges (*result);
5681 /* Implementation of `sdata' variable. */
5683 static const struct internalvar_funcs sdata_funcs =
5690 /* module initialization */
5692 _initialize_tracepoint (void)
5694 struct cmd_list_element *c;
5696 /* Explicitly create without lookup, since that tries to create a
5697 value with a void typed value, and when we get here, gdbarch
5698 isn't initialized yet. At this point, we're quite sure there
5699 isn't another convenience variable of the same name. */
5700 create_internalvar_type_lazy ("_sdata", &sdata_funcs, NULL);
5702 traceframe_number = -1;
5703 tracepoint_number = -1;
5705 add_info ("scope", scope_info,
5706 _("List the variables local to a scope"));
5708 add_cmd ("tracepoints", class_trace, NULL,
5709 _("Tracing of program execution without stopping the program."),
5712 add_com ("tdump", class_trace, trace_dump_command,
5713 _("Print everything collected at the current tracepoint."));
5715 add_com ("tsave", class_trace, trace_save_command, _("\
5716 Save the trace data to a file.\n\
5717 Use the '-ctf' option to save the data to CTF format.\n\
5718 Use the '-r' option to direct the target to save directly to the file,\n\
5719 using its own filesystem."));
5721 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
5722 Define a trace state variable.\n\
5723 Argument is a $-prefixed name, optionally followed\n\
5724 by '=' and an expression that sets the initial value\n\
5725 at the start of tracing."));
5726 set_cmd_completer (c, expression_completer);
5728 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
5729 Delete one or more trace state variables.\n\
5730 Arguments are the names of the variables to delete.\n\
5731 If no arguments are supplied, delete all variables."), &deletelist);
5732 /* FIXME add a trace variable completer. */
5734 add_info ("tvariables", tvariables_info, _("\
5735 Status of trace state variables and their values.\n\
5738 add_info ("static-tracepoint-markers",
5739 info_static_tracepoint_markers_command, _("\
5740 List target static tracepoints markers.\n\
5743 add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
5744 Select a trace frame;\n\
5745 No argument means forward by one frame; '-' means backward by one frame."),
5746 &tfindlist, "tfind ", 1, &cmdlist);
5748 add_cmd ("outside", class_trace, trace_find_outside_command, _("\
5749 Select a trace frame whose PC is outside the given range (exclusive).\n\
5750 Usage: tfind outside addr1, addr2"),
5753 add_cmd ("range", class_trace, trace_find_range_command, _("\
5754 Select a trace frame whose PC is in the given range (inclusive).\n\
5755 Usage: tfind range addr1,addr2"),
5758 add_cmd ("line", class_trace, trace_find_line_command, _("\
5759 Select a trace frame by source line.\n\
5760 Argument can be a line number (with optional source file),\n\
5761 a function name, or '*' followed by an address.\n\
5762 Default argument is 'the next source line that was traced'."),
5765 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
5766 Select a trace frame by tracepoint number.\n\
5767 Default is the tracepoint for the current trace frame."),
5770 add_cmd ("pc", class_trace, trace_find_pc_command, _("\
5771 Select a trace frame by PC.\n\
5772 Default is the current PC, or the PC of the current trace frame."),
5775 add_cmd ("end", class_trace, trace_find_end_command, _("\
5776 De-select any trace frame and resume 'live' debugging."),
5779 add_alias_cmd ("none", "end", class_trace, 0, &tfindlist);
5781 add_cmd ("start", class_trace, trace_find_start_command,
5782 _("Select the first trace frame in the trace buffer."),
5785 add_com ("tstatus", class_trace, trace_status_command,
5786 _("Display the status of the current trace data collection."));
5788 add_com ("tstop", class_trace, trace_stop_command, _("\
5789 Stop trace data collection.\n\
5790 Usage: tstop [ <notes> ... ]\n\
5791 Any arguments supplied are recorded with the trace as a stop reason and\n\
5792 reported by tstatus (if the target supports trace notes)."));
5794 add_com ("tstart", class_trace, trace_start_command, _("\
5795 Start trace data collection.\n\
5796 Usage: tstart [ <notes> ... ]\n\
5797 Any arguments supplied are recorded with the trace as a note and\n\
5798 reported by tstatus (if the target supports trace notes)."));
5800 add_com ("end", class_trace, end_actions_pseudocommand, _("\
5801 Ends a list of commands or actions.\n\
5802 Several GDB commands allow you to enter a list of commands or actions.\n\
5803 Entering \"end\" on a line by itself is the normal way to terminate\n\
5805 Note: the \"end\" command cannot be used at the gdb prompt."));
5807 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
5808 Specify single-stepping behavior at a tracepoint.\n\
5809 Argument is number of instructions to trace in single-step mode\n\
5810 following the tracepoint. This command is normally followed by\n\
5811 one or more \"collect\" commands, to specify what to collect\n\
5812 while single-stepping.\n\n\
5813 Note: this command can only be used in a tracepoint \"actions\" list."));
5815 add_com_alias ("ws", "while-stepping", class_alias, 0);
5816 add_com_alias ("stepping", "while-stepping", class_alias, 0);
5818 add_com ("collect", class_trace, collect_pseudocommand, _("\
5819 Specify one or more data items to be collected at a tracepoint.\n\
5820 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5821 collect all data (variables, registers) referenced by that expression.\n\
5822 Also accepts the following special arguments:\n\
5823 $regs -- all registers.\n\
5824 $args -- all function arguments.\n\
5825 $locals -- all variables local to the block/function scope.\n\
5826 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5827 Note: this command can only be used in a tracepoint \"actions\" list."));
5829 add_com ("teval", class_trace, teval_pseudocommand, _("\
5830 Specify one or more expressions to be evaluated at a tracepoint.\n\
5831 Accepts a comma-separated list of (one or more) expressions.\n\
5832 The result of each evaluation will be discarded.\n\
5833 Note: this command can only be used in a tracepoint \"actions\" list."));
5835 add_com ("actions", class_trace, trace_actions_command, _("\
5836 Specify the actions to be taken at a tracepoint.\n\
5837 Tracepoint actions may include collecting of specified data,\n\
5838 single-stepping, or enabling/disabling other tracepoints,\n\
5839 depending on target's capabilities."));
5841 default_collect = xstrdup ("");
5842 add_setshow_string_cmd ("default-collect", class_trace,
5843 &default_collect, _("\
5844 Set the list of expressions to collect by default"), _("\
5845 Show the list of expressions to collect by default"), NULL,
5847 &setlist, &showlist);
5849 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
5850 &disconnected_tracing, _("\
5851 Set whether tracing continues after GDB disconnects."), _("\
5852 Show whether tracing continues after GDB disconnects."), _("\
5853 Use this to continue a tracing run even if GDB disconnects\n\
5854 or detaches from the target. You can reconnect later and look at\n\
5855 trace data collected in the meantime."),
5856 set_disconnected_tracing,
5861 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
5862 &circular_trace_buffer, _("\
5863 Set target's use of circular trace buffer."), _("\
5864 Show target's use of circular trace buffer."), _("\
5865 Use this to make the trace buffer into a circular buffer,\n\
5866 which will discard traceframes (oldest first) instead of filling\n\
5867 up and stopping the trace run."),
5868 set_circular_trace_buffer,
5873 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class,
5874 &trace_buffer_size, _("\
5875 Set requested size of trace buffer."), _("\
5876 Show requested size of trace buffer."), _("\
5877 Use this to choose a size for the trace buffer. Some targets\n\
5878 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
5879 disables any attempt to set the buffer size and lets the target choose."),
5880 set_trace_buffer_size, NULL,
5881 &setlist, &showlist);
5883 add_setshow_string_cmd ("trace-user", class_trace,
5885 Set the user name to use for current and future trace runs"), _("\
5886 Show the user name to use for current and future trace runs"), NULL,
5887 set_trace_user, NULL,
5888 &setlist, &showlist);
5890 add_setshow_string_cmd ("trace-notes", class_trace,
5892 Set notes string to use for current and future trace runs"), _("\
5893 Show the notes string to use for current and future trace runs"), NULL,
5894 set_trace_notes, NULL,
5895 &setlist, &showlist);
5897 add_setshow_string_cmd ("trace-stop-notes", class_trace,
5898 &trace_stop_notes, _("\
5899 Set notes string to use for future tstop commands"), _("\
5900 Show the notes string to use for future tstop commands"), NULL,
5901 set_trace_stop_notes, NULL,
5902 &setlist, &showlist);
5906 add_target_with_completer (&tfile_ops, filename_completer);