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)
2986 warning (_("No current trace frame."));
2990 old_chain = make_cleanup (null_cleanup, NULL);
2991 t = get_tracepoint (tracepoint_number);
2994 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2997 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2998 tracepoint_number, traceframe_number);
3000 /* The current frame is a trap frame if the frame PC is equal
3001 to the tracepoint PC. If not, then the current frame was
3002 collected during single-stepping. */
3004 regcache = get_current_regcache ();
3006 /* If the traceframe's address matches any of the tracepoint's
3007 locations, assume it is a direct hit rather than a while-stepping
3008 frame. (FIXME this is not reliable, should record each frame's
3011 for (loc = t->base.loc; loc; loc = loc->next)
3012 if (loc->address == regcache_read_pc (regcache))
3015 actions = all_tracepoint_actions_and_cleanup (&t->base);
3017 trace_dump_actions (actions, 0, stepping_frame, from_tty);
3019 do_cleanups (old_chain);
3022 /* Encode a piece of a tracepoint's source-level definition in a form
3023 that is suitable for both protocol and saving in files. */
3024 /* This version does not do multiple encodes for long strings; it should
3025 return an offset to the next piece to encode. FIXME */
3028 encode_source_string (int tpnum, ULONGEST addr,
3029 char *srctype, char *src, char *buf, int buf_size)
3031 if (80 + strlen (srctype) > buf_size)
3032 error (_("Buffer too small for source encoding"));
3033 sprintf (buf, "%x:%s:%s:%x:%x:",
3034 tpnum, phex_nz (addr, sizeof (addr)),
3035 srctype, 0, (int) strlen (src));
3036 if (strlen (buf) + strlen (src) * 2 >= buf_size)
3037 error (_("Source string too long for buffer"));
3038 bin2hex ((gdb_byte *) src, buf + strlen (buf), 0);
3042 /* Free trace file writer. */
3045 trace_file_writer_xfree (void *arg)
3047 struct trace_file_writer *writer = arg;
3049 writer->ops->dtor (writer);
3053 /* TFILE trace writer. */
3055 struct tfile_trace_file_writer
3057 struct trace_file_writer base;
3059 /* File pointer to tfile trace file. */
3061 /* Path name of the tfile trace file. */
3065 /* This is the implementation of trace_file_write_ops method
3066 target_save. We just call the generic target
3067 target_save_trace_data to do target-side saving. */
3070 tfile_target_save (struct trace_file_writer *self,
3071 const char *filename)
3073 int err = target_save_trace_data (filename);
3078 /* This is the implementation of trace_file_write_ops method
3082 tfile_dtor (struct trace_file_writer *self)
3084 struct tfile_trace_file_writer *writer
3085 = (struct tfile_trace_file_writer *) self;
3087 xfree (writer->pathname);
3089 if (writer->fp != NULL)
3090 fclose (writer->fp);
3093 /* This is the implementation of trace_file_write_ops method
3094 start. It creates the trace file FILENAME and registers some
3098 tfile_start (struct trace_file_writer *self, const char *filename)
3100 struct tfile_trace_file_writer *writer
3101 = (struct tfile_trace_file_writer *) self;
3103 writer->pathname = tilde_expand (filename);
3104 writer->fp = gdb_fopen_cloexec (writer->pathname, "wb");
3105 if (writer->fp == NULL)
3106 error (_("Unable to open file '%s' for saving trace data (%s)"),
3107 filename, safe_strerror (errno));
3110 /* This is the implementation of trace_file_write_ops method
3111 write_header. Write the TFILE header. */
3114 tfile_write_header (struct trace_file_writer *self)
3116 struct tfile_trace_file_writer *writer
3117 = (struct tfile_trace_file_writer *) self;
3120 /* Write a file header, with a high-bit-set char to indicate a
3121 binary file, plus a hint as what this file is, and a version
3122 number in case of future needs. */
3123 written = fwrite ("\x7fTRACE0\n", 8, 1, writer->fp);
3125 perror_with_name (writer->pathname);
3128 /* This is the implementation of trace_file_write_ops method
3129 write_regblock_type. Write the size of register block. */
3132 tfile_write_regblock_type (struct trace_file_writer *self, int size)
3134 struct tfile_trace_file_writer *writer
3135 = (struct tfile_trace_file_writer *) self;
3137 fprintf (writer->fp, "R %x\n", size);
3140 /* This is the implementation of trace_file_write_ops method
3144 tfile_write_status (struct trace_file_writer *self,
3145 struct trace_status *ts)
3147 struct tfile_trace_file_writer *writer
3148 = (struct tfile_trace_file_writer *) self;
3150 fprintf (writer->fp, "status %c;%s",
3151 (ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
3152 if (ts->stop_reason == tracepoint_error
3153 || ts->stop_reason == tstop_command)
3155 char *buf = (char *) alloca (strlen (ts->stop_desc) * 2 + 1);
3157 bin2hex ((gdb_byte *) ts->stop_desc, buf, 0);
3158 fprintf (writer->fp, ":%s", buf);
3160 fprintf (writer->fp, ":%x", ts->stopping_tracepoint);
3161 if (ts->traceframe_count >= 0)
3162 fprintf (writer->fp, ";tframes:%x", ts->traceframe_count);
3163 if (ts->traceframes_created >= 0)
3164 fprintf (writer->fp, ";tcreated:%x", ts->traceframes_created);
3165 if (ts->buffer_free >= 0)
3166 fprintf (writer->fp, ";tfree:%x", ts->buffer_free);
3167 if (ts->buffer_size >= 0)
3168 fprintf (writer->fp, ";tsize:%x", ts->buffer_size);
3169 if (ts->disconnected_tracing)
3170 fprintf (writer->fp, ";disconn:%x", ts->disconnected_tracing);
3171 if (ts->circular_buffer)
3172 fprintf (writer->fp, ";circular:%x", ts->circular_buffer);
3173 if (ts->notes != NULL)
3175 char *buf = (char *) alloca (strlen (ts->notes) * 2 + 1);
3177 bin2hex ((gdb_byte *) ts->notes, buf, 0);
3178 fprintf (writer->fp, ";notes:%s", buf);
3180 if (ts->user_name != NULL)
3182 char *buf = (char *) alloca (strlen (ts->user_name) * 2 + 1);
3184 bin2hex ((gdb_byte *) ts->user_name, buf, 0);
3185 fprintf (writer->fp, ";username:%s", buf);
3187 fprintf (writer->fp, "\n");
3190 /* This is the implementation of trace_file_write_ops method
3191 write_uploaded_tsv. */
3194 tfile_write_uploaded_tsv (struct trace_file_writer *self,
3195 struct uploaded_tsv *utsv)
3198 struct tfile_trace_file_writer *writer
3199 = (struct tfile_trace_file_writer *) self;
3203 buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
3204 bin2hex ((gdb_byte *) (utsv->name), buf, 0);
3207 fprintf (writer->fp, "tsv %x:%s:%x:%s\n",
3208 utsv->number, phex_nz (utsv->initial_value, 8),
3209 utsv->builtin, buf);
3215 #define MAX_TRACE_UPLOAD 2000
3217 /* This is the implementation of trace_file_write_ops method
3218 write_uploaded_tp. */
3221 tfile_write_uploaded_tp (struct trace_file_writer *self,
3222 struct uploaded_tp *utp)
3224 struct tfile_trace_file_writer *writer
3225 = (struct tfile_trace_file_writer *) self;
3228 char buf[MAX_TRACE_UPLOAD];
3230 fprintf (writer->fp, "tp T%x:%s:%c:%x:%x",
3231 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
3232 (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
3233 if (utp->type == bp_fast_tracepoint)
3234 fprintf (writer->fp, ":F%x", utp->orig_size);
3236 fprintf (writer->fp,
3237 ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
3239 fprintf (writer->fp, "\n");
3240 for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
3241 fprintf (writer->fp, "tp A%x:%s:%s\n",
3242 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
3243 for (a = 0; VEC_iterate (char_ptr, utp->step_actions, a, act); ++a)
3244 fprintf (writer->fp, "tp S%x:%s:%s\n",
3245 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
3248 encode_source_string (utp->number, utp->addr,
3249 "at", utp->at_string, buf, MAX_TRACE_UPLOAD);
3250 fprintf (writer->fp, "tp Z%s\n", buf);
3252 if (utp->cond_string)
3254 encode_source_string (utp->number, utp->addr,
3255 "cond", utp->cond_string,
3256 buf, MAX_TRACE_UPLOAD);
3257 fprintf (writer->fp, "tp Z%s\n", buf);
3259 for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
3261 encode_source_string (utp->number, utp->addr, "cmd", act,
3262 buf, MAX_TRACE_UPLOAD);
3263 fprintf (writer->fp, "tp Z%s\n", buf);
3265 fprintf (writer->fp, "tp V%x:%s:%x:%s\n",
3266 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
3268 phex_nz (utp->traceframe_usage,
3269 sizeof (utp->traceframe_usage)));
3272 /* This is the implementation of trace_file_write_ops method
3273 write_definition_end. */
3276 tfile_write_definition_end (struct trace_file_writer *self)
3278 struct tfile_trace_file_writer *writer
3279 = (struct tfile_trace_file_writer *) self;
3281 fprintf (writer->fp, "\n");
3284 /* This is the implementation of trace_file_write_ops method
3288 tfile_write_raw_data (struct trace_file_writer *self, gdb_byte *buf,
3291 struct tfile_trace_file_writer *writer
3292 = (struct tfile_trace_file_writer *) self;
3294 if (fwrite (buf, len, 1, writer->fp) < 1)
3295 perror_with_name (writer->pathname);
3298 /* This is the implementation of trace_file_write_ops method
3302 tfile_end (struct trace_file_writer *self)
3304 struct tfile_trace_file_writer *writer
3305 = (struct tfile_trace_file_writer *) self;
3306 uint32_t gotten = 0;
3308 /* Mark the end of trace data. */
3309 if (fwrite (&gotten, 4, 1, writer->fp) < 1)
3310 perror_with_name (writer->pathname);
3313 /* Operations to write trace buffers into TFILE format. */
3315 static const struct trace_file_write_ops tfile_write_ops =
3321 tfile_write_regblock_type,
3323 tfile_write_uploaded_tsv,
3324 tfile_write_uploaded_tp,
3325 tfile_write_definition_end,
3326 tfile_write_raw_data,
3331 /* Helper macros. */
3333 #define TRACE_WRITE_R_BLOCK(writer, buf, size) \
3334 writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
3335 #define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size) \
3336 writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
3338 #define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size) \
3339 writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
3341 #define TRACE_WRITE_V_BLOCK(writer, num, val) \
3342 writer->ops->frame_ops->write_v_block ((writer), (num), (val))
3344 /* Save tracepoint data to file named FILENAME through WRITER. WRITER
3345 determines the trace file format. If TARGET_DOES_SAVE is non-zero,
3346 the save is performed on the target, otherwise GDB obtains all trace
3347 data and saves it locally. */
3350 trace_save (const char *filename, struct trace_file_writer *writer,
3351 int target_does_save)
3353 struct trace_status *ts = current_trace_status ();
3355 struct uploaded_tp *uploaded_tps = NULL, *utp;
3356 struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
3358 ULONGEST offset = 0;
3359 gdb_byte buf[MAX_TRACE_UPLOAD];
3360 #define MAX_TRACE_UPLOAD 2000
3362 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
3364 /* If the target is to save the data to a file on its own, then just
3365 send the command and be done with it. */
3366 if (target_does_save)
3368 if (!writer->ops->target_save (writer, filename))
3369 error (_("Target failed to save trace data to '%s'."),
3374 /* Get the trace status first before opening the file, so if the
3375 target is losing, we can get out without touching files. */
3376 status = target_get_trace_status (ts);
3378 writer->ops->start (writer, filename);
3380 writer->ops->write_header (writer);
3382 /* Write descriptive info. */
3384 /* Write out the size of a register block. */
3385 writer->ops->write_regblock_type (writer, trace_regblock_size);
3387 /* Write out status of the tracing run (aka "tstatus" info). */
3388 writer->ops->write_status (writer, ts);
3390 /* Note that we want to upload tracepoints and save those, rather
3391 than simply writing out the local ones, because the user may have
3392 changed tracepoints in GDB in preparation for a future tracing
3393 run, or maybe just mass-deleted all types of breakpoints as part
3394 of cleaning up. So as not to contaminate the session, leave the
3395 data in its uploaded form, don't make into real tracepoints. */
3397 /* Get trace state variables first, they may be checked when parsing
3398 uploaded commands. */
3400 target_upload_trace_state_variables (&uploaded_tsvs);
3402 for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
3403 writer->ops->write_uploaded_tsv (writer, utsv);
3405 free_uploaded_tsvs (&uploaded_tsvs);
3407 target_upload_tracepoints (&uploaded_tps);
3409 for (utp = uploaded_tps; utp; utp = utp->next)
3410 target_get_tracepoint_status (NULL, utp);
3412 for (utp = uploaded_tps; utp; utp = utp->next)
3413 writer->ops->write_uploaded_tp (writer, utp);
3415 free_uploaded_tps (&uploaded_tps);
3417 /* Mark the end of the definition section. */
3418 writer->ops->write_definition_end (writer);
3420 /* Get and write the trace data proper. */
3425 /* The writer supports writing the contents of trace buffer
3426 directly to trace file. Don't parse the contents of trace
3428 if (writer->ops->write_trace_buffer != NULL)
3430 /* We ask for big blocks, in the hopes of efficiency, but
3431 will take less if the target has packet size limitations
3433 gotten = target_get_raw_trace_data (buf, offset,
3436 error (_("Failure to get requested trace buffer data"));
3437 /* No more data is forthcoming, we're done. */
3441 writer->ops->write_trace_buffer (writer, buf, gotten);
3449 /* Parse the trace buffers according to how data are stored
3450 in trace buffer in GDBserver. */
3452 gotten = target_get_raw_trace_data (buf, offset, 6);
3457 /* Read the first six bytes in, which is the tracepoint
3458 number and trace frame size. */
3460 extract_unsigned_integer (&buf[0], 2, byte_order);
3462 tf_size = (uint32_t)
3463 extract_unsigned_integer (&buf[2], 4, byte_order);
3465 writer->ops->frame_ops->start (writer, tp_num);
3474 for (block = 0; block < tf_size; )
3476 gdb_byte block_type;
3478 /* We'll fetch one block each time, in order to
3479 handle the extremely large 'M' block. We first
3480 fetch one byte to get the type of the block. */
3481 gotten = target_get_raw_trace_data (buf, offset, 1);
3483 error (_("Failure to get requested trace buffer data"));
3489 block_type = buf[0];
3494 = target_get_raw_trace_data (buf, offset,
3495 trace_regblock_size);
3496 if (gotten < trace_regblock_size)
3497 error (_("Failure to get requested trace"
3500 TRACE_WRITE_R_BLOCK (writer, buf,
3501 trace_regblock_size);
3505 unsigned short mlen;
3510 t = target_get_raw_trace_data (buf,offset, 10);
3512 error (_("Failure to get requested trace"
3520 extract_unsigned_integer (buf, 8,
3522 mlen = (unsigned short)
3523 extract_unsigned_integer (&buf[8], 2,
3526 TRACE_WRITE_M_BLOCK_HEADER (writer, addr,
3529 /* The memory contents in 'M' block may be
3530 very large. Fetch the data from the target
3531 and write them into file one by one. */
3532 for (j = 0; j < mlen; )
3534 unsigned int read_length;
3536 if (mlen - j > MAX_TRACE_UPLOAD)
3537 read_length = MAX_TRACE_UPLOAD;
3539 read_length = mlen - j;
3541 t = target_get_raw_trace_data (buf,
3544 if (t < read_length)
3545 error (_("Failure to get requested"
3546 " trace buffer data"));
3548 TRACE_WRITE_M_BLOCK_MEMORY (writer, buf,
3552 gotten += read_length;
3563 = target_get_raw_trace_data (buf, offset,
3566 error (_("Failure to get requested"
3567 " trace buffer data"));
3569 vnum = (int) extract_signed_integer (buf,
3573 = extract_signed_integer (&buf[4], 8,
3576 TRACE_WRITE_V_BLOCK (writer, vnum, val);
3580 error (_("Unknown block type '%c' (0x%x) in"
3582 block_type, block_type);
3592 writer->ops->frame_ops->end (writer);
3596 writer->ops->end (writer);
3599 /* Return a trace writer for TFILE format. */
3601 static struct trace_file_writer *
3602 tfile_trace_file_writer_new (void)
3604 struct tfile_trace_file_writer *writer
3605 = xmalloc (sizeof (struct tfile_trace_file_writer));
3607 writer->base.ops = &tfile_write_ops;
3609 writer->pathname = NULL;
3611 return (struct trace_file_writer *) writer;
3615 trace_save_command (char *args, int from_tty)
3617 int target_does_save = 0;
3619 char *filename = NULL;
3620 struct cleanup *back_to;
3621 int generate_ctf = 0;
3622 struct trace_file_writer *writer = NULL;
3625 error_no_arg (_("file in which to save trace data"));
3627 argv = gdb_buildargv (args);
3628 back_to = make_cleanup_freeargv (argv);
3630 for (; *argv; ++argv)
3632 if (strcmp (*argv, "-r") == 0)
3633 target_does_save = 1;
3634 if (strcmp (*argv, "-ctf") == 0)
3636 else if (**argv == '-')
3637 error (_("unknown option `%s'"), *argv);
3643 error_no_arg (_("file in which to save trace data"));
3646 writer = ctf_trace_file_writer_new ();
3648 writer = tfile_trace_file_writer_new ();
3650 make_cleanup (trace_file_writer_xfree, writer);
3652 trace_save (filename, writer, target_does_save);
3655 printf_filtered (_("Trace data saved to %s '%s'.\n"),
3656 generate_ctf ? "directory" : "file", filename);
3658 do_cleanups (back_to);
3661 /* Save the trace data to file FILENAME of tfile format. */
3664 trace_save_tfile (const char *filename, int target_does_save)
3666 struct trace_file_writer *writer;
3667 struct cleanup *back_to;
3669 writer = tfile_trace_file_writer_new ();
3670 back_to = make_cleanup (trace_file_writer_xfree, writer);
3671 trace_save (filename, writer, target_does_save);
3672 do_cleanups (back_to);
3675 /* Save the trace data to dir DIRNAME of ctf format. */
3678 trace_save_ctf (const char *dirname, int target_does_save)
3680 struct trace_file_writer *writer;
3681 struct cleanup *back_to;
3683 writer = ctf_trace_file_writer_new ();
3684 back_to = make_cleanup (trace_file_writer_xfree, writer);
3686 trace_save (dirname, writer, target_does_save);
3687 do_cleanups (back_to);
3690 /* Tell the target what to do with an ongoing tracing run if GDB
3691 disconnects for some reason. */
3694 set_disconnected_tracing (char *args, int from_tty,
3695 struct cmd_list_element *c)
3697 target_set_disconnected_tracing (disconnected_tracing);
3701 set_circular_trace_buffer (char *args, int from_tty,
3702 struct cmd_list_element *c)
3704 target_set_circular_trace_buffer (circular_trace_buffer);
3708 set_trace_buffer_size (char *args, int from_tty,
3709 struct cmd_list_element *c)
3711 target_set_trace_buffer_size (trace_buffer_size);
3715 set_trace_user (char *args, int from_tty,
3716 struct cmd_list_element *c)
3720 ret = target_set_trace_notes (trace_user, NULL, NULL);
3723 warning (_("Target does not support trace notes, user ignored"));
3727 set_trace_notes (char *args, int from_tty,
3728 struct cmd_list_element *c)
3732 ret = target_set_trace_notes (NULL, trace_notes, NULL);
3735 warning (_("Target does not support trace notes, note ignored"));
3739 set_trace_stop_notes (char *args, int from_tty,
3740 struct cmd_list_element *c)
3744 ret = target_set_trace_notes (NULL, NULL, trace_stop_notes);
3747 warning (_("Target does not support trace notes, stop note ignored"));
3750 /* Convert the memory pointed to by mem into hex, placing result in buf.
3751 * Return a pointer to the last char put in buf (null)
3752 * "stolen" from sparc-stub.c
3755 static const char hexchars[] = "0123456789abcdef";
3758 mem2hex (gdb_byte *mem, char *buf, int count)
3766 *buf++ = hexchars[ch >> 4];
3767 *buf++ = hexchars[ch & 0xf];
3776 get_traceframe_number (void)
3778 return traceframe_number;
3782 get_tracepoint_number (void)
3784 return tracepoint_number;
3787 /* Make the traceframe NUM be the current trace frame. Does nothing
3788 if NUM is already current. */
3791 set_current_traceframe (int num)
3795 if (traceframe_number == num)
3797 /* Nothing to do. */
3801 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
3804 warning (_("could not change traceframe"));
3806 set_traceframe_num (newnum);
3808 /* Changing the traceframe changes our view of registers and of the
3810 registers_changed ();
3812 clear_traceframe_info ();
3815 /* Make the traceframe NUM be the current trace frame, and do nothing
3819 set_traceframe_number (int num)
3821 traceframe_number = num;
3824 /* A cleanup used when switching away and back from tfind mode. */
3826 struct current_traceframe_cleanup
3828 /* The traceframe we were inspecting. */
3829 int traceframe_number;
3833 do_restore_current_traceframe_cleanup (void *arg)
3835 struct current_traceframe_cleanup *old = arg;
3837 set_current_traceframe (old->traceframe_number);
3841 restore_current_traceframe_cleanup_dtor (void *arg)
3843 struct current_traceframe_cleanup *old = arg;
3849 make_cleanup_restore_current_traceframe (void)
3851 struct current_traceframe_cleanup *old;
3853 old = xmalloc (sizeof (struct current_traceframe_cleanup));
3854 old->traceframe_number = traceframe_number;
3856 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
3857 restore_current_traceframe_cleanup_dtor);
3861 make_cleanup_restore_traceframe_number (void)
3863 return make_cleanup_restore_integer (&traceframe_number);
3866 /* Given a number and address, return an uploaded tracepoint with that
3867 number, creating if necessary. */
3869 struct uploaded_tp *
3870 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
3872 struct uploaded_tp *utp;
3874 for (utp = *utpp; utp; utp = utp->next)
3875 if (utp->number == num && utp->addr == addr)
3877 utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
3878 memset (utp, 0, sizeof (struct uploaded_tp));
3881 utp->actions = NULL;
3882 utp->step_actions = NULL;
3883 utp->cmd_strings = NULL;
3890 free_uploaded_tps (struct uploaded_tp **utpp)
3892 struct uploaded_tp *next_one;
3896 next_one = (*utpp)->next;
3902 /* Given a number and address, return an uploaded tracepoint with that
3903 number, creating if necessary. */
3905 struct uploaded_tsv *
3906 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
3908 struct uploaded_tsv *utsv;
3910 for (utsv = *utsvp; utsv; utsv = utsv->next)
3911 if (utsv->number == num)
3913 utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
3914 memset (utsv, 0, sizeof (struct uploaded_tsv));
3916 utsv->next = *utsvp;
3922 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3924 struct uploaded_tsv *next_one;
3928 next_one = (*utsvp)->next;
3934 /* FIXME this function is heuristic and will miss the cases where the
3935 conditional is semantically identical but differs in whitespace,
3936 such as "x == 0" vs "x==0". */
3939 cond_string_is_same (char *str1, char *str2)
3941 if (str1 == NULL || str2 == NULL)
3942 return (str1 == str2);
3944 return (strcmp (str1, str2) == 0);
3947 /* Look for an existing tracepoint that seems similar enough to the
3948 uploaded one. Enablement isn't compared, because the user can
3949 toggle that freely, and may have done so in anticipation of the
3950 next trace run. Return the location of matched tracepoint. */
3952 static struct bp_location *
3953 find_matching_tracepoint_location (struct uploaded_tp *utp)
3955 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
3957 struct breakpoint *b;
3958 struct bp_location *loc;
3960 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
3962 struct tracepoint *t = (struct tracepoint *) b;
3964 if (b->type == utp->type
3965 && t->step_count == utp->step
3966 && t->pass_count == utp->pass
3967 && cond_string_is_same (t->base.cond_string, utp->cond_string)
3968 /* FIXME also test actions. */
3971 /* Scan the locations for an address match. */
3972 for (loc = b->loc; loc; loc = loc->next)
3974 if (loc->address == utp->addr)
3982 /* Given a list of tracepoints uploaded from a target, attempt to
3983 match them up with existing tracepoints, and create new ones if not
3987 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3989 struct uploaded_tp *utp;
3990 /* A set of tracepoints which are modified. */
3991 VEC(breakpoint_p) *modified_tp = NULL;
3993 struct breakpoint *b;
3995 /* Look for GDB tracepoints that match up with our uploaded versions. */
3996 for (utp = *uploaded_tps; utp; utp = utp->next)
3998 struct bp_location *loc;
3999 struct tracepoint *t;
4001 loc = find_matching_tracepoint_location (utp);
4006 /* Mark this location as already inserted. */
4008 t = (struct tracepoint *) loc->owner;
4009 printf_filtered (_("Assuming tracepoint %d is same "
4010 "as target's tracepoint %d at %s.\n"),
4011 loc->owner->number, utp->number,
4012 paddress (loc->gdbarch, utp->addr));
4014 /* The tracepoint LOC->owner was modified (the location LOC
4015 was marked as inserted in the target). Save it in
4016 MODIFIED_TP if not there yet. The 'breakpoint-modified'
4017 observers will be notified later once for each tracepoint
4018 saved in MODIFIED_TP. */
4020 VEC_iterate (breakpoint_p, modified_tp, ix, b);
4022 if (b == loc->owner)
4028 VEC_safe_push (breakpoint_p, modified_tp, loc->owner);
4032 t = create_tracepoint_from_upload (utp);
4034 printf_filtered (_("Created tracepoint %d for "
4035 "target's tracepoint %d at %s.\n"),
4036 t->base.number, utp->number,
4037 paddress (get_current_arch (), utp->addr));
4039 printf_filtered (_("Failed to create tracepoint for target's "
4040 "tracepoint %d at %s, skipping it.\n"),
4042 paddress (get_current_arch (), utp->addr));
4044 /* Whether found or created, record the number used by the
4045 target, to help with mapping target tracepoints back to their
4046 counterparts here. */
4048 t->number_on_target = utp->number;
4051 /* Notify 'breakpoint-modified' observer that at least one of B's
4052 locations was changed. */
4053 for (ix = 0; VEC_iterate (breakpoint_p, modified_tp, ix, b); ix++)
4054 observer_notify_breakpoint_modified (b);
4056 VEC_free (breakpoint_p, modified_tp);
4057 free_uploaded_tps (uploaded_tps);
4060 /* Trace state variables don't have much to identify them beyond their
4061 name, so just use that to detect matches. */
4063 static struct trace_state_variable *
4064 find_matching_tsv (struct uploaded_tsv *utsv)
4069 return find_trace_state_variable (utsv->name);
4072 static struct trace_state_variable *
4073 create_tsv_from_upload (struct uploaded_tsv *utsv)
4075 const char *namebase;
4078 struct trace_state_variable *tsv;
4079 struct cleanup *old_chain;
4083 namebase = utsv->name;
4084 buf = xstrprintf ("%s", namebase);
4089 buf = xstrprintf ("%s_%d", namebase, try_num++);
4092 /* Fish for a name that is not in use. */
4093 /* (should check against all internal vars?) */
4094 while (find_trace_state_variable (buf))
4097 buf = xstrprintf ("%s_%d", namebase, try_num++);
4100 old_chain = make_cleanup (xfree, buf);
4102 /* We have an available name, create the variable. */
4103 tsv = create_trace_state_variable (buf);
4104 tsv->initial_value = utsv->initial_value;
4105 tsv->builtin = utsv->builtin;
4107 observer_notify_tsv_created (tsv);
4109 do_cleanups (old_chain);
4114 /* Given a list of uploaded trace state variables, try to match them
4115 up with existing variables, or create additional ones. */
4118 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
4121 struct uploaded_tsv *utsv;
4122 struct trace_state_variable *tsv;
4125 /* Most likely some numbers will have to be reassigned as part of
4126 the merge, so clear them all in anticipation. */
4127 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
4130 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
4132 tsv = find_matching_tsv (utsv);
4136 printf_filtered (_("Assuming trace state variable $%s "
4137 "is same as target's variable %d.\n"),
4138 tsv->name, utsv->number);
4142 tsv = create_tsv_from_upload (utsv);
4144 printf_filtered (_("Created trace state variable "
4145 "$%s for target's variable %d.\n"),
4146 tsv->name, utsv->number);
4148 /* Give precedence to numberings that come from the target. */
4150 tsv->number = utsv->number;
4153 /* Renumber everything that didn't get a target-assigned number. */
4155 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
4156 if (tsv->number > highest)
4157 highest = tsv->number;
4160 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
4161 if (tsv->number == 0)
4162 tsv->number = highest++;
4164 free_uploaded_tsvs (uploaded_tsvs);
4167 /* target tfile command */
4169 static struct target_ops tfile_ops;
4171 /* Fill in tfile_ops with its defined operations and properties. */
4173 #define TRACE_HEADER_SIZE 8
4175 static char *trace_filename;
4176 static int trace_fd = -1;
4177 static off_t trace_frames_offset;
4178 static off_t cur_offset;
4179 static int cur_data_size;
4180 int trace_regblock_size;
4182 static void tfile_interp_line (char *line,
4183 struct uploaded_tp **utpp,
4184 struct uploaded_tsv **utsvp);
4186 /* Read SIZE bytes into READBUF from the trace frame, starting at
4187 TRACE_FD's current position. Note that this call `read'
4188 underneath, hence it advances the file's seek position. Throws an
4189 error if the `read' syscall fails, or less than SIZE bytes are
4193 tfile_read (gdb_byte *readbuf, int size)
4197 gotten = read (trace_fd, readbuf, size);
4199 perror_with_name (trace_filename);
4200 else if (gotten < size)
4201 error (_("Premature end of file while reading trace file"));
4205 tfile_open (char *filename, int from_tty)
4207 volatile struct gdb_exception ex;
4209 struct cleanup *old_chain;
4212 char header[TRACE_HEADER_SIZE];
4213 char linebuf[1000]; /* Should be max remote packet size or so. */
4216 struct trace_status *ts;
4217 struct uploaded_tp *uploaded_tps = NULL;
4218 struct uploaded_tsv *uploaded_tsvs = NULL;
4220 target_preopen (from_tty);
4222 error (_("No trace file specified."));
4224 filename = tilde_expand (filename);
4225 if (!IS_ABSOLUTE_PATH(filename))
4227 temp = concat (current_directory, "/", filename, (char *) NULL);
4232 old_chain = make_cleanup (xfree, filename);
4234 flags = O_BINARY | O_LARGEFILE;
4236 scratch_chan = gdb_open_cloexec (filename, flags, 0);
4237 if (scratch_chan < 0)
4238 perror_with_name (filename);
4240 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
4242 discard_cleanups (old_chain); /* Don't free filename any more. */
4243 unpush_target (&tfile_ops);
4245 trace_filename = xstrdup (filename);
4246 trace_fd = scratch_chan;
4249 /* Read the file header and test for validity. */
4250 tfile_read ((gdb_byte *) &header, TRACE_HEADER_SIZE);
4252 bytes += TRACE_HEADER_SIZE;
4253 if (!(header[0] == 0x7f
4254 && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
4255 error (_("File is not a valid trace file."));
4257 push_target (&tfile_ops);
4259 trace_regblock_size = 0;
4260 ts = current_trace_status ();
4261 /* We know we're working with a file. Record its name. */
4262 ts->filename = trace_filename;
4263 /* Set defaults in case there is no status line. */
4264 ts->running_known = 0;
4265 ts->stop_reason = trace_stop_reason_unknown;
4266 ts->traceframe_count = -1;
4267 ts->buffer_free = 0;
4268 ts->disconnected_tracing = 0;
4269 ts->circular_buffer = 0;
4271 TRY_CATCH (ex, RETURN_MASK_ALL)
4273 /* Read through a section of newline-terminated lines that
4274 define things like tracepoints. */
4278 tfile_read (&byte, 1);
4283 /* Empty line marks end of the definition section. */
4288 tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
4291 linebuf[i++] = byte;
4293 error (_("Excessively long lines in trace file"));
4296 /* Record the starting offset of the binary trace data. */
4297 trace_frames_offset = bytes;
4299 /* If we don't have a blocksize, we can't interpret the
4301 if (trace_regblock_size == 0)
4302 error (_("No register block size recorded in trace file"));
4306 /* Pop the partially set up target. */
4308 throw_exception (ex);
4311 if (ts->traceframe_count <= 0)
4312 warning (_("No traceframes present in this file."));
4314 /* Add the file's tracepoints and variables into the current mix. */
4316 /* Get trace state variables first, they may be checked when parsing
4317 uploaded commands. */
4318 merge_uploaded_trace_state_variables (&uploaded_tsvs);
4320 merge_uploaded_tracepoints (&uploaded_tps);
4323 /* Interpret the given line from the definitions part of the trace
4327 tfile_interp_line (char *line, struct uploaded_tp **utpp,
4328 struct uploaded_tsv **utsvp)
4332 if (strncmp (p, "R ", strlen ("R ")) == 0)
4335 trace_regblock_size = strtol (p, &p, 16);
4337 else if (strncmp (p, "status ", strlen ("status ")) == 0)
4339 p += strlen ("status ");
4340 parse_trace_status (p, current_trace_status ());
4342 else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
4344 p += strlen ("tp ");
4345 parse_tracepoint_definition (p, utpp);
4347 else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
4349 p += strlen ("tsv ");
4350 parse_tsv_definition (p, utsvp);
4353 warning (_("Ignoring trace file definition \"%s\""), line);
4356 /* Parse the part of trace status syntax that is shared between
4357 the remote protocol and the trace file reader. */
4360 parse_trace_status (char *line, struct trace_status *ts)
4362 char *p = line, *p1, *p2, *p3, *p_temp;
4366 ts->running_known = 1;
4367 ts->running = (*p++ == '1');
4368 ts->stop_reason = trace_stop_reason_unknown;
4369 xfree (ts->stop_desc);
4370 ts->stop_desc = NULL;
4371 ts->traceframe_count = -1;
4372 ts->traceframes_created = -1;
4373 ts->buffer_free = -1;
4374 ts->buffer_size = -1;
4375 ts->disconnected_tracing = 0;
4376 ts->circular_buffer = 0;
4377 xfree (ts->user_name);
4378 ts->user_name = NULL;
4381 ts->start_time = ts->stop_time = 0;
4385 p1 = strchr (p, ':');
4387 error (_("Malformed trace status, at %s\n\
4388 Status line: '%s'\n"), p, line);
4389 p3 = strchr (p, ';');
4391 p3 = p + strlen (p);
4392 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
4394 p = unpack_varlen_hex (++p1, &val);
4395 ts->stop_reason = trace_buffer_full;
4397 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
4399 p = unpack_varlen_hex (++p1, &val);
4400 ts->stop_reason = trace_never_run;
4402 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
4405 p = unpack_varlen_hex (++p1, &val);
4406 ts->stop_reason = tracepoint_passcount;
4407 ts->stopping_tracepoint = val;
4409 else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
4411 p2 = strchr (++p1, ':');
4419 ts->stop_desc = xmalloc (strlen (line));
4420 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
4421 ts->stop_desc[end] = '\0';
4424 ts->stop_desc = xstrdup ("");
4426 p = unpack_varlen_hex (++p2, &val);
4427 ts->stop_reason = tstop_command;
4429 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
4431 p = unpack_varlen_hex (++p1, &val);
4432 ts->stop_reason = trace_disconnected;
4434 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
4436 p2 = strchr (++p1, ':');
4439 ts->stop_desc = xmalloc ((p2 - p1) / 2 + 1);
4440 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
4441 ts->stop_desc[end] = '\0';
4444 ts->stop_desc = xstrdup ("");
4446 p = unpack_varlen_hex (++p2, &val);
4447 ts->stopping_tracepoint = val;
4448 ts->stop_reason = tracepoint_error;
4450 else if (strncmp (p, "tframes", p1 - p) == 0)
4452 p = unpack_varlen_hex (++p1, &val);
4453 ts->traceframe_count = val;
4455 else if (strncmp (p, "tcreated", p1 - p) == 0)
4457 p = unpack_varlen_hex (++p1, &val);
4458 ts->traceframes_created = val;
4460 else if (strncmp (p, "tfree", p1 - p) == 0)
4462 p = unpack_varlen_hex (++p1, &val);
4463 ts->buffer_free = val;
4465 else if (strncmp (p, "tsize", p1 - p) == 0)
4467 p = unpack_varlen_hex (++p1, &val);
4468 ts->buffer_size = val;
4470 else if (strncmp (p, "disconn", p1 - p) == 0)
4472 p = unpack_varlen_hex (++p1, &val);
4473 ts->disconnected_tracing = val;
4475 else if (strncmp (p, "circular", p1 - p) == 0)
4477 p = unpack_varlen_hex (++p1, &val);
4478 ts->circular_buffer = val;
4480 else if (strncmp (p, "starttime", p1 - p) == 0)
4482 p = unpack_varlen_hex (++p1, &val);
4483 ts->start_time = val;
4485 else if (strncmp (p, "stoptime", p1 - p) == 0)
4487 p = unpack_varlen_hex (++p1, &val);
4488 ts->stop_time = val;
4490 else if (strncmp (p, "username", p1 - p) == 0)
4493 ts->user_name = xmalloc (strlen (p) / 2);
4494 end = hex2bin (p1, (gdb_byte *) ts->user_name, (p3 - p1) / 2);
4495 ts->user_name[end] = '\0';
4498 else if (strncmp (p, "notes", p1 - p) == 0)
4501 ts->notes = xmalloc (strlen (p) / 2);
4502 end = hex2bin (p1, (gdb_byte *) ts->notes, (p3 - p1) / 2);
4503 ts->notes[end] = '\0';
4508 /* Silently skip unknown optional info. */
4509 p_temp = strchr (p1 + 1, ';');
4513 /* Must be at the end. */
4520 parse_tracepoint_status (char *p, struct breakpoint *bp,
4521 struct uploaded_tp *utp)
4524 struct tracepoint *tp = (struct tracepoint *) bp;
4526 p = unpack_varlen_hex (p, &uval);
4528 tp->base.hit_count += uval;
4530 utp->hit_count += uval;
4531 p = unpack_varlen_hex (p + 1, &uval);
4533 tp->traceframe_usage += uval;
4535 utp->traceframe_usage += uval;
4536 /* Ignore any extra, allowing for future extensions. */
4539 /* Given a line of text defining a part of a tracepoint, parse it into
4540 an "uploaded tracepoint". */
4543 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
4547 ULONGEST num, addr, step, pass, orig_size, xlen, start;
4550 char *cond, *srctype, *buf;
4551 struct uploaded_tp *utp = NULL;
4554 /* Both tracepoint and action definitions start with the same number
4555 and address sequence. */
4557 p = unpack_varlen_hex (p, &num);
4558 p++; /* skip a colon */
4559 p = unpack_varlen_hex (p, &addr);
4560 p++; /* skip a colon */
4563 enabled = (*p++ == 'E');
4564 p++; /* skip a colon */
4565 p = unpack_varlen_hex (p, &step);
4566 p++; /* skip a colon */
4567 p = unpack_varlen_hex (p, &pass);
4568 type = bp_tracepoint;
4570 /* Thumb through optional fields. */
4573 p++; /* skip a colon */
4576 type = bp_fast_tracepoint;
4578 p = unpack_varlen_hex (p, &orig_size);
4582 type = bp_static_tracepoint;
4588 p = unpack_varlen_hex (p, &xlen);
4589 p++; /* skip a comma */
4590 cond = (char *) xmalloc (2 * xlen + 1);
4591 strncpy (cond, p, 2 * xlen);
4592 cond[2 * xlen] = '\0';
4596 warning (_("Unrecognized char '%c' in tracepoint "
4597 "definition, skipping rest"), *p);
4599 utp = get_uploaded_tp (num, addr, utpp);
4601 utp->enabled = enabled;
4606 else if (piece == 'A')
4608 utp = get_uploaded_tp (num, addr, utpp);
4609 VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
4611 else if (piece == 'S')
4613 utp = get_uploaded_tp (num, addr, utpp);
4614 VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
4616 else if (piece == 'Z')
4618 /* Parse a chunk of source form definition. */
4619 utp = get_uploaded_tp (num, addr, utpp);
4621 p = strchr (p, ':');
4622 p++; /* skip a colon */
4623 p = unpack_varlen_hex (p, &start);
4624 p++; /* skip a colon */
4625 p = unpack_varlen_hex (p, &xlen);
4626 p++; /* skip a colon */
4628 buf = alloca (strlen (line));
4630 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
4633 if (strncmp (srctype, "at:", strlen ("at:")) == 0)
4634 utp->at_string = xstrdup (buf);
4635 else if (strncmp (srctype, "cond:", strlen ("cond:")) == 0)
4636 utp->cond_string = xstrdup (buf);
4637 else if (strncmp (srctype, "cmd:", strlen ("cmd:")) == 0)
4638 VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
4640 else if (piece == 'V')
4642 utp = get_uploaded_tp (num, addr, utpp);
4644 parse_tracepoint_status (p, NULL, utp);
4648 /* Don't error out, the target might be sending us optional
4649 info that we don't care about. */
4650 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
4654 /* Convert a textual description of a trace state variable into an
4658 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
4661 ULONGEST num, initval, builtin;
4663 struct uploaded_tsv *utsv = NULL;
4665 buf = alloca (strlen (line));
4668 p = unpack_varlen_hex (p, &num);
4669 p++; /* skip a colon */
4670 p = unpack_varlen_hex (p, &initval);
4671 p++; /* skip a colon */
4672 p = unpack_varlen_hex (p, &builtin);
4673 p++; /* skip a colon */
4674 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
4677 utsv = get_uploaded_tsv (num, utsvp);
4678 utsv->initial_value = initval;
4679 utsv->builtin = builtin;
4680 utsv->name = xstrdup (buf);
4683 /* Close the trace file and generally clean up. */
4695 xfree (trace_filename);
4696 trace_filename = NULL;
4698 trace_reset_local_state ();
4702 tfile_files_info (struct target_ops *t)
4704 printf_filtered ("\t`%s'\n", trace_filename);
4707 /* The trace status for a file is that tracing can never be run. */
4710 tfile_get_trace_status (struct trace_status *ts)
4712 /* Other bits of trace status were collected as part of opening the
4713 trace files, so nothing to do here. */
4719 tfile_get_tracepoint_status (struct breakpoint *tp, struct uploaded_tp *utp)
4721 /* Other bits of trace status were collected as part of opening the
4722 trace files, so nothing to do here. */
4725 /* Given the position of a traceframe in the file, figure out what
4726 address the frame was collected at. This would normally be the
4727 value of a collected PC register, but if not available, we
4731 tfile_get_traceframe_address (off_t tframe_offset)
4735 struct tracepoint *tp;
4736 off_t saved_offset = cur_offset;
4738 /* FIXME dig pc out of collected registers. */
4740 /* Fall back to using tracepoint address. */
4741 lseek (trace_fd, tframe_offset, SEEK_SET);
4742 tfile_read ((gdb_byte *) &tpnum, 2);
4743 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
4745 (target_gdbarch ()));
4747 tp = get_tracepoint_by_number_on_target (tpnum);
4748 /* FIXME this is a poor heuristic if multiple locations. */
4749 if (tp && tp->base.loc)
4750 addr = tp->base.loc->address;
4752 /* Restore our seek position. */
4753 cur_offset = saved_offset;
4754 lseek (trace_fd, cur_offset, SEEK_SET);
4758 /* Given a type of search and some parameters, scan the collection of
4759 traceframes in the file looking for a match. When found, return
4760 both the traceframe and tracepoint number, otherwise -1 for
4764 tfile_trace_find (enum trace_find_type type, int num,
4765 CORE_ADDR addr1, CORE_ADDR addr2, int *tpp)
4768 int tfnum = 0, found = 0;
4769 unsigned int data_size;
4770 struct tracepoint *tp;
4771 off_t offset, tframe_offset;
4781 lseek (trace_fd, trace_frames_offset, SEEK_SET);
4782 offset = trace_frames_offset;
4785 tframe_offset = offset;
4786 tfile_read ((gdb_byte *) &tpnum, 2);
4787 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
4789 (target_gdbarch ()));
4793 tfile_read ((gdb_byte *) &data_size, 4);
4794 data_size = (unsigned int) extract_unsigned_integer
4795 ((gdb_byte *) &data_size, 4,
4796 gdbarch_byte_order (target_gdbarch ()));
4799 if (type == tfind_number)
4801 /* Looking for a specific trace frame. */
4807 /* Start from the _next_ trace frame. */
4808 if (tfnum > traceframe_number)
4813 tfaddr = tfile_get_traceframe_address (tframe_offset);
4814 if (tfaddr == addr1)
4818 tp = get_tracepoint (num);
4819 if (tp && tpnum == tp->number_on_target)
4823 tfaddr = tfile_get_traceframe_address (tframe_offset);
4824 if (addr1 <= tfaddr && tfaddr <= addr2)
4828 tfaddr = tfile_get_traceframe_address (tframe_offset);
4829 if (!(addr1 <= tfaddr && tfaddr <= addr2))
4833 internal_error (__FILE__, __LINE__, _("unknown tfind type"));
4842 cur_offset = offset;
4843 cur_data_size = data_size;
4847 /* Skip past the traceframe's data. */
4848 lseek (trace_fd, data_size, SEEK_CUR);
4849 offset += data_size;
4850 /* Update our own count of traceframes. */
4853 /* Did not find what we were looking for. */
4859 /* Prototype of the callback passed to tframe_walk_blocks. */
4860 typedef int (*walk_blocks_callback_func) (char blocktype, void *data);
4862 /* Callback for traceframe_walk_blocks, used to find a given block
4863 type in a traceframe. */
4866 match_blocktype (char blocktype, void *data)
4868 char *wantedp = data;
4870 if (*wantedp == blocktype)
4876 /* Walk over all traceframe block starting at POS offset from
4877 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4878 unmodified. If CALLBACK returns true, this returns the position in
4879 the traceframe where the block is found, relative to the start of
4880 the traceframe (cur_offset). Returns -1 if no callback call
4881 returned true, indicating that all blocks have been walked. */
4884 traceframe_walk_blocks (walk_blocks_callback_func callback,
4885 int pos, void *data)
4887 /* Iterate through a traceframe's blocks, looking for a block of the
4890 lseek (trace_fd, cur_offset + pos, SEEK_SET);
4891 while (pos < cur_data_size)
4893 unsigned short mlen;
4896 tfile_read ((gdb_byte *) &block_type, 1);
4900 if ((*callback) (block_type, data))
4906 lseek (trace_fd, cur_offset + pos + trace_regblock_size, SEEK_SET);
4907 pos += trace_regblock_size;
4910 lseek (trace_fd, cur_offset + pos + 8, SEEK_SET);
4911 tfile_read ((gdb_byte *) &mlen, 2);
4912 mlen = (unsigned short)
4913 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
4915 (target_gdbarch ()));
4916 lseek (trace_fd, mlen, SEEK_CUR);
4917 pos += (8 + 2 + mlen);
4920 lseek (trace_fd, cur_offset + pos + 4 + 8, SEEK_SET);
4924 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4925 block_type, block_type);
4933 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4934 position offset of a block of type TYPE_WANTED in the current trace
4935 frame, starting at POS. Returns -1 if no such block was found. */
4938 traceframe_find_block_type (char type_wanted, int pos)
4940 return traceframe_walk_blocks (match_blocktype, pos, &type_wanted);
4943 /* Look for a block of saved registers in the traceframe, and get the
4944 requested register from it. */
4947 tfile_fetch_registers (struct target_ops *ops,
4948 struct regcache *regcache, int regno)
4950 struct gdbarch *gdbarch = get_regcache_arch (regcache);
4951 int offset, regn, regsize, pc_regno;
4954 /* An uninitialized reg size says we're not going to be
4955 successful at getting register blocks. */
4956 if (!trace_regblock_size)
4959 regs = alloca (trace_regblock_size);
4961 if (traceframe_find_block_type ('R', 0) >= 0)
4963 tfile_read (regs, trace_regblock_size);
4965 /* Assume the block is laid out in GDB register number order,
4966 each register with the size that it has in GDB. */
4968 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
4970 regsize = register_size (gdbarch, regn);
4971 /* Make sure we stay within block bounds. */
4972 if (offset + regsize >= trace_regblock_size)
4974 if (regcache_register_status (regcache, regn) == REG_UNKNOWN)
4978 regcache_raw_supply (regcache, regno, regs + offset);
4981 else if (regno == -1)
4983 regcache_raw_supply (regcache, regn, regs + offset);
4991 /* We get here if no register data has been found. Mark registers
4993 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
4994 regcache_raw_supply (regcache, regn, NULL);
4996 /* We can often usefully guess that the PC is going to be the same
4997 as the address of the tracepoint. */
4998 pc_regno = gdbarch_pc_regnum (gdbarch);
4999 if (pc_regno >= 0 && (regno == -1 || regno == pc_regno))
5001 struct tracepoint *tp = get_tracepoint (tracepoint_number);
5003 if (tp && tp->base.loc)
5005 /* But don't try to guess if tracepoint is multi-location... */
5006 if (tp->base.loc->next)
5008 warning (_("Tracepoint %d has multiple "
5009 "locations, cannot infer $pc"),
5013 /* ... or does while-stepping. */
5014 if (tp->step_count > 0)
5016 warning (_("Tracepoint %d does while-stepping, "
5017 "cannot infer $pc"),
5022 store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
5023 gdbarch_byte_order (gdbarch),
5024 tp->base.loc->address);
5025 regcache_raw_supply (regcache, pc_regno, regs);
5031 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
5032 const char *annex, gdb_byte *readbuf,
5033 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
5035 /* We're only doing regular memory for now. */
5036 if (object != TARGET_OBJECT_MEMORY)
5039 if (readbuf == NULL)
5040 error (_("tfile_xfer_partial: trace file is read-only"));
5042 if (traceframe_number != -1)
5046 /* Iterate through the traceframe's blocks, looking for
5048 while ((pos = traceframe_find_block_type ('M', pos)) >= 0)
5050 ULONGEST maddr, amt;
5051 unsigned short mlen;
5052 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
5054 tfile_read ((gdb_byte *) &maddr, 8);
5055 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
5057 tfile_read ((gdb_byte *) &mlen, 2);
5058 mlen = (unsigned short)
5059 extract_unsigned_integer ((gdb_byte *) &mlen, 2, byte_order);
5061 /* If the block includes the first part of the desired
5062 range, return as much it has; GDB will re-request the
5063 remainder, which might be in a different block of this
5065 if (maddr <= offset && offset < (maddr + mlen))
5067 amt = (maddr + mlen) - offset;
5071 if (maddr != offset)
5072 lseek (trace_fd, offset - maddr, SEEK_CUR);
5073 tfile_read (readbuf, amt);
5077 /* Skip over this block. */
5078 pos += (8 + 2 + mlen);
5082 /* It's unduly pedantic to refuse to look at the executable for
5083 read-only pieces; so do the equivalent of readonly regions aka
5085 /* FIXME account for relocation at some point. */
5092 for (s = exec_bfd->sections; s; s = s->next)
5094 if ((s->flags & SEC_LOAD) == 0
5095 || (s->flags & SEC_READONLY) == 0)
5099 size = bfd_get_section_size (s);
5100 if (vma <= offset && offset < (vma + size))
5104 amt = (vma + size) - offset;
5108 amt = bfd_get_section_contents (exec_bfd, s,
5109 readbuf, offset - vma, amt);
5115 /* Indicate failure to find the requested memory block. */
5119 /* Iterate through the blocks of a trace frame, looking for a 'V'
5120 block with a matching tsv number. */
5123 tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
5128 /* Iterate over blocks in current frame and find the last 'V'
5129 block in which tsv number is TSVNUM. In one trace frame, there
5130 may be multiple 'V' blocks created for a given trace variable,
5131 and the last matched 'V' block contains the updated value. */
5133 while ((pos = traceframe_find_block_type ('V', pos)) >= 0)
5137 tfile_read ((gdb_byte *) &vnum, 4);
5138 vnum = (int) extract_signed_integer ((gdb_byte *) &vnum, 4,
5140 (target_gdbarch ()));
5143 tfile_read ((gdb_byte *) val, 8);
5144 *val = extract_signed_integer ((gdb_byte *) val, 8,
5146 (target_gdbarch ()));
5156 tfile_has_all_memory (struct target_ops *ops)
5162 tfile_has_memory (struct target_ops *ops)
5168 tfile_has_stack (struct target_ops *ops)
5170 return traceframe_number != -1;
5174 tfile_has_registers (struct target_ops *ops)
5176 return traceframe_number != -1;
5179 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
5180 object for the tfile target's current traceframe. */
5183 build_traceframe_info (char blocktype, void *data)
5185 struct traceframe_info *info = data;
5191 struct mem_range *r;
5193 unsigned short mlen;
5195 tfile_read ((gdb_byte *) &maddr, 8);
5196 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
5198 (target_gdbarch ()));
5199 tfile_read ((gdb_byte *) &mlen, 2);
5200 mlen = (unsigned short)
5201 extract_unsigned_integer ((gdb_byte *) &mlen,
5202 2, gdbarch_byte_order
5203 (target_gdbarch ()));
5205 r = VEC_safe_push (mem_range_s, info->memory, NULL);
5218 warning (_("Unhandled trace block type (%d) '%c ' "
5219 "while building trace frame info."),
5220 blocktype, blocktype);
5227 static struct traceframe_info *
5228 tfile_traceframe_info (void)
5230 struct traceframe_info *info = XCNEW (struct traceframe_info);
5232 traceframe_walk_blocks (build_traceframe_info, 0, info);
5237 init_tfile_ops (void)
5239 tfile_ops.to_shortname = "tfile";
5240 tfile_ops.to_longname = "Local trace dump file";
5242 = "Use a trace file as a target. Specify the filename of the trace file.";
5243 tfile_ops.to_open = tfile_open;
5244 tfile_ops.to_close = tfile_close;
5245 tfile_ops.to_fetch_registers = tfile_fetch_registers;
5246 tfile_ops.to_xfer_partial = tfile_xfer_partial;
5247 tfile_ops.to_files_info = tfile_files_info;
5248 tfile_ops.to_get_trace_status = tfile_get_trace_status;
5249 tfile_ops.to_get_tracepoint_status = tfile_get_tracepoint_status;
5250 tfile_ops.to_trace_find = tfile_trace_find;
5251 tfile_ops.to_get_trace_state_variable_value
5252 = tfile_get_trace_state_variable_value;
5253 tfile_ops.to_stratum = process_stratum;
5254 tfile_ops.to_has_all_memory = tfile_has_all_memory;
5255 tfile_ops.to_has_memory = tfile_has_memory;
5256 tfile_ops.to_has_stack = tfile_has_stack;
5257 tfile_ops.to_has_registers = tfile_has_registers;
5258 tfile_ops.to_traceframe_info = tfile_traceframe_info;
5259 tfile_ops.to_magic = OPS_MAGIC;
5263 free_current_marker (void *arg)
5265 struct static_tracepoint_marker **marker_p = arg;
5267 if (*marker_p != NULL)
5269 release_static_tracepoint_marker (*marker_p);
5276 /* Given a line of text defining a static tracepoint marker, parse it
5277 into a "static tracepoint marker" object. Throws an error is
5278 parsing fails. If PP is non-null, it points to one past the end of
5279 the parsed marker definition. */
5282 parse_static_tracepoint_marker_definition (char *line, char **pp,
5283 struct static_tracepoint_marker *marker)
5290 p = unpack_varlen_hex (p, &addr);
5291 p++; /* skip a colon */
5293 marker->gdbarch = target_gdbarch ();
5294 marker->address = (CORE_ADDR) addr;
5296 endp = strchr (p, ':');
5298 error (_("bad marker definition: %s"), line);
5300 marker->str_id = xmalloc (endp - p + 1);
5301 end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
5302 marker->str_id[end] = '\0';
5305 p++; /* skip a colon */
5307 marker->extra = xmalloc (strlen (p) + 1);
5308 end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
5309 marker->extra[end] = '\0';
5315 /* Release a static tracepoint marker's contents. Note that the
5316 object itself isn't released here. There objects are usually on
5320 release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
5322 xfree (marker->str_id);
5323 marker->str_id = NULL;
5326 /* Print MARKER to gdb_stdout. */
5329 print_one_static_tracepoint_marker (int count,
5330 struct static_tracepoint_marker *marker)
5332 struct command_line *l;
5335 char wrap_indent[80];
5336 char extra_field_indent[80];
5337 struct ui_out *uiout = current_uiout;
5338 struct cleanup *bkpt_chain;
5339 VEC(breakpoint_p) *tracepoints;
5341 struct symtab_and_line sal;
5345 sal.pc = marker->address;
5347 tracepoints = static_tracepoints_here (marker->address);
5349 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "marker");
5351 /* A counter field to help readability. This is not a stable
5353 ui_out_field_int (uiout, "count", count);
5355 ui_out_field_string (uiout, "marker-id", marker->str_id);
5357 ui_out_field_fmt (uiout, "enabled", "%c",
5358 !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
5359 ui_out_spaces (uiout, 2);
5361 strcpy (wrap_indent, " ");
5363 if (gdbarch_addr_bit (marker->gdbarch) <= 32)
5364 strcat (wrap_indent, " ");
5366 strcat (wrap_indent, " ");
5368 strcpy (extra_field_indent, " ");
5370 ui_out_field_core_addr (uiout, "addr", marker->gdbarch, marker->address);
5372 sal = find_pc_line (marker->address, 0);
5373 sym = find_pc_sect_function (marker->address, NULL);
5376 ui_out_text (uiout, "in ");
5377 ui_out_field_string (uiout, "func",
5378 SYMBOL_PRINT_NAME (sym));
5379 ui_out_wrap_hint (uiout, wrap_indent);
5380 ui_out_text (uiout, " at ");
5383 ui_out_field_skip (uiout, "func");
5385 if (sal.symtab != NULL)
5387 ui_out_field_string (uiout, "file",
5388 symtab_to_filename_for_display (sal.symtab));
5389 ui_out_text (uiout, ":");
5391 if (ui_out_is_mi_like_p (uiout))
5393 const char *fullname = symtab_to_fullname (sal.symtab);
5395 ui_out_field_string (uiout, "fullname", fullname);
5398 ui_out_field_skip (uiout, "fullname");
5400 ui_out_field_int (uiout, "line", sal.line);
5404 ui_out_field_skip (uiout, "fullname");
5405 ui_out_field_skip (uiout, "line");
5408 ui_out_text (uiout, "\n");
5409 ui_out_text (uiout, extra_field_indent);
5410 ui_out_text (uiout, _("Data: \""));
5411 ui_out_field_string (uiout, "extra-data", marker->extra);
5412 ui_out_text (uiout, "\"\n");
5414 if (!VEC_empty (breakpoint_p, tracepoints))
5416 struct cleanup *cleanup_chain;
5418 struct breakpoint *b;
5420 cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
5423 ui_out_text (uiout, extra_field_indent);
5424 ui_out_text (uiout, _("Probed by static tracepoints: "));
5425 for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
5428 ui_out_text (uiout, ", ");
5429 ui_out_text (uiout, "#");
5430 ui_out_field_int (uiout, "tracepoint-id", b->number);
5433 do_cleanups (cleanup_chain);
5435 if (ui_out_is_mi_like_p (uiout))
5436 ui_out_field_int (uiout, "number-of-tracepoints",
5437 VEC_length(breakpoint_p, tracepoints));
5439 ui_out_text (uiout, "\n");
5441 VEC_free (breakpoint_p, tracepoints);
5443 do_cleanups (bkpt_chain);
5447 info_static_tracepoint_markers_command (char *arg, int from_tty)
5449 VEC(static_tracepoint_marker_p) *markers;
5450 struct cleanup *old_chain;
5451 struct static_tracepoint_marker *marker;
5452 struct ui_out *uiout = current_uiout;
5455 /* We don't have to check target_can_use_agent and agent's capability on
5456 static tracepoint here, in order to be compatible with older GDBserver.
5457 We don't check USE_AGENT is true or not, because static tracepoints
5458 don't work without in-process agent, so we don't bother users to type
5459 `set agent on' when to use static tracepoint. */
5462 = make_cleanup_ui_out_table_begin_end (uiout, 5, -1,
5463 "StaticTracepointMarkersTable");
5465 ui_out_table_header (uiout, 7, ui_left, "counter", "Cnt");
5467 ui_out_table_header (uiout, 40, ui_left, "marker-id", "ID");
5469 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
5470 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
5471 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");
5473 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
5474 ui_out_table_header (uiout, 40, ui_noalign, "what", "What");
5476 ui_out_table_body (uiout);
5478 markers = target_static_tracepoint_markers_by_strid (NULL);
5479 make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
5482 VEC_iterate (static_tracepoint_marker_p,
5483 markers, i, marker);
5486 print_one_static_tracepoint_marker (i + 1, marker);
5487 release_static_tracepoint_marker (marker);
5490 do_cleanups (old_chain);
5493 /* The $_sdata convenience variable is a bit special. We don't know
5494 for sure type of the value until we actually have a chance to fetch
5495 the data --- the size of the object depends on what has been
5496 collected. We solve this by making $_sdata be an internalvar that
5497 creates a new value on access. */
5499 /* Return a new value with the correct type for the sdata object of
5500 the current trace frame. Return a void value if there's no object
5503 static struct value *
5504 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var,
5510 /* We need to read the whole object before we know its size. */
5511 size = target_read_alloc (¤t_target,
5512 TARGET_OBJECT_STATIC_TRACE_DATA,
5519 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
5521 v = allocate_value (type);
5522 memcpy (value_contents_raw (v), buf, size);
5527 return allocate_value (builtin_type (gdbarch)->builtin_void);
5530 #if !defined(HAVE_LIBEXPAT)
5532 struct traceframe_info *
5533 parse_traceframe_info (const char *tframe_info)
5535 static int have_warned;
5540 warning (_("Can not parse XML trace frame info; XML support "
5541 "was disabled at compile time"));
5547 #else /* HAVE_LIBEXPAT */
5549 #include "xml-support.h"
5551 /* Handle the start of a <memory> element. */
5554 traceframe_info_start_memory (struct gdb_xml_parser *parser,
5555 const struct gdb_xml_element *element,
5556 void *user_data, VEC(gdb_xml_value_s) *attributes)
5558 struct traceframe_info *info = user_data;
5559 struct mem_range *r = VEC_safe_push (mem_range_s, info->memory, NULL);
5560 ULONGEST *start_p, *length_p;
5562 start_p = xml_find_attribute (attributes, "start")->value;
5563 length_p = xml_find_attribute (attributes, "length")->value;
5565 r->start = *start_p;
5566 r->length = *length_p;
5569 /* Discard the constructed trace frame info (if an error occurs). */
5572 free_result (void *p)
5574 struct traceframe_info *result = p;
5576 free_traceframe_info (result);
5579 /* The allowed elements and attributes for an XML memory map. */
5581 static const struct gdb_xml_attribute memory_attributes[] = {
5582 { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
5583 { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
5584 { NULL, GDB_XML_AF_NONE, NULL, NULL }
5587 static const struct gdb_xml_element traceframe_info_children[] = {
5588 { "memory", memory_attributes, NULL,
5589 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
5590 traceframe_info_start_memory, NULL },
5591 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
5594 static const struct gdb_xml_element traceframe_info_elements[] = {
5595 { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
5597 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
5600 /* Parse a traceframe-info XML document. */
5602 struct traceframe_info *
5603 parse_traceframe_info (const char *tframe_info)
5605 struct traceframe_info *result;
5606 struct cleanup *back_to;
5608 result = XCNEW (struct traceframe_info);
5609 back_to = make_cleanup (free_result, result);
5611 if (gdb_xml_parse_quick (_("trace frame info"),
5612 "traceframe-info.dtd", traceframe_info_elements,
5613 tframe_info, result) == 0)
5615 /* Parsed successfully, keep the result. */
5616 discard_cleanups (back_to);
5621 do_cleanups (back_to);
5625 #endif /* HAVE_LIBEXPAT */
5627 /* Returns the traceframe_info object for the current traceframe.
5628 This is where we avoid re-fetching the object from the target if we
5629 already have it cached. */
5631 static struct traceframe_info *
5632 get_traceframe_info (void)
5634 if (traceframe_info == NULL)
5635 traceframe_info = target_traceframe_info ();
5637 return traceframe_info;
5640 /* If the target supports the query, return in RESULT the set of
5641 collected memory in the current traceframe, found within the LEN
5642 bytes range starting at MEMADDR. Returns true if the target
5643 supports the query, otherwise returns false, and RESULT is left
5647 traceframe_available_memory (VEC(mem_range_s) **result,
5648 CORE_ADDR memaddr, ULONGEST len)
5650 struct traceframe_info *info = get_traceframe_info ();
5654 struct mem_range *r;
5659 for (i = 0; VEC_iterate (mem_range_s, info->memory, i, r); i++)
5660 if (mem_ranges_overlap (r->start, r->length, memaddr, len))
5662 ULONGEST lo1, hi1, lo2, hi2;
5663 struct mem_range *nr;
5666 hi1 = memaddr + len;
5669 hi2 = r->start + r->length;
5671 nr = VEC_safe_push (mem_range_s, *result, NULL);
5673 nr->start = max (lo1, lo2);
5674 nr->length = min (hi1, hi2) - nr->start;
5677 normalize_mem_ranges (*result);
5684 /* Implementation of `sdata' variable. */
5686 static const struct internalvar_funcs sdata_funcs =
5693 /* module initialization */
5695 _initialize_tracepoint (void)
5697 struct cmd_list_element *c;
5699 /* Explicitly create without lookup, since that tries to create a
5700 value with a void typed value, and when we get here, gdbarch
5701 isn't initialized yet. At this point, we're quite sure there
5702 isn't another convenience variable of the same name. */
5703 create_internalvar_type_lazy ("_sdata", &sdata_funcs, NULL);
5705 traceframe_number = -1;
5706 tracepoint_number = -1;
5708 add_info ("scope", scope_info,
5709 _("List the variables local to a scope"));
5711 add_cmd ("tracepoints", class_trace, NULL,
5712 _("Tracing of program execution without stopping the program."),
5715 add_com ("tdump", class_trace, trace_dump_command,
5716 _("Print everything collected at the current tracepoint."));
5718 add_com ("tsave", class_trace, trace_save_command, _("\
5719 Save the trace data to a file.\n\
5720 Use the '-ctf' option to save the data to CTF format.\n\
5721 Use the '-r' option to direct the target to save directly to the file,\n\
5722 using its own filesystem."));
5724 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
5725 Define a trace state variable.\n\
5726 Argument is a $-prefixed name, optionally followed\n\
5727 by '=' and an expression that sets the initial value\n\
5728 at the start of tracing."));
5729 set_cmd_completer (c, expression_completer);
5731 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
5732 Delete one or more trace state variables.\n\
5733 Arguments are the names of the variables to delete.\n\
5734 If no arguments are supplied, delete all variables."), &deletelist);
5735 /* FIXME add a trace variable completer. */
5737 add_info ("tvariables", tvariables_info, _("\
5738 Status of trace state variables and their values.\n\
5741 add_info ("static-tracepoint-markers",
5742 info_static_tracepoint_markers_command, _("\
5743 List target static tracepoints markers.\n\
5746 add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
5747 Select a trace frame;\n\
5748 No argument means forward by one frame; '-' means backward by one frame."),
5749 &tfindlist, "tfind ", 1, &cmdlist);
5751 add_cmd ("outside", class_trace, trace_find_outside_command, _("\
5752 Select a trace frame whose PC is outside the given range (exclusive).\n\
5753 Usage: tfind outside addr1, addr2"),
5756 add_cmd ("range", class_trace, trace_find_range_command, _("\
5757 Select a trace frame whose PC is in the given range (inclusive).\n\
5758 Usage: tfind range addr1,addr2"),
5761 add_cmd ("line", class_trace, trace_find_line_command, _("\
5762 Select a trace frame by source line.\n\
5763 Argument can be a line number (with optional source file),\n\
5764 a function name, or '*' followed by an address.\n\
5765 Default argument is 'the next source line that was traced'."),
5768 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
5769 Select a trace frame by tracepoint number.\n\
5770 Default is the tracepoint for the current trace frame."),
5773 add_cmd ("pc", class_trace, trace_find_pc_command, _("\
5774 Select a trace frame by PC.\n\
5775 Default is the current PC, or the PC of the current trace frame."),
5778 add_cmd ("end", class_trace, trace_find_end_command, _("\
5779 De-select any trace frame and resume 'live' debugging."),
5782 add_alias_cmd ("none", "end", class_trace, 0, &tfindlist);
5784 add_cmd ("start", class_trace, trace_find_start_command,
5785 _("Select the first trace frame in the trace buffer."),
5788 add_com ("tstatus", class_trace, trace_status_command,
5789 _("Display the status of the current trace data collection."));
5791 add_com ("tstop", class_trace, trace_stop_command, _("\
5792 Stop trace data collection.\n\
5793 Usage: tstop [ <notes> ... ]\n\
5794 Any arguments supplied are recorded with the trace as a stop reason and\n\
5795 reported by tstatus (if the target supports trace notes)."));
5797 add_com ("tstart", class_trace, trace_start_command, _("\
5798 Start trace data collection.\n\
5799 Usage: tstart [ <notes> ... ]\n\
5800 Any arguments supplied are recorded with the trace as a note and\n\
5801 reported by tstatus (if the target supports trace notes)."));
5803 add_com ("end", class_trace, end_actions_pseudocommand, _("\
5804 Ends a list of commands or actions.\n\
5805 Several GDB commands allow you to enter a list of commands or actions.\n\
5806 Entering \"end\" on a line by itself is the normal way to terminate\n\
5808 Note: the \"end\" command cannot be used at the gdb prompt."));
5810 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
5811 Specify single-stepping behavior at a tracepoint.\n\
5812 Argument is number of instructions to trace in single-step mode\n\
5813 following the tracepoint. This command is normally followed by\n\
5814 one or more \"collect\" commands, to specify what to collect\n\
5815 while single-stepping.\n\n\
5816 Note: this command can only be used in a tracepoint \"actions\" list."));
5818 add_com_alias ("ws", "while-stepping", class_alias, 0);
5819 add_com_alias ("stepping", "while-stepping", class_alias, 0);
5821 add_com ("collect", class_trace, collect_pseudocommand, _("\
5822 Specify one or more data items to be collected at a tracepoint.\n\
5823 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5824 collect all data (variables, registers) referenced by that expression.\n\
5825 Also accepts the following special arguments:\n\
5826 $regs -- all registers.\n\
5827 $args -- all function arguments.\n\
5828 $locals -- all variables local to the block/function scope.\n\
5829 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5830 Note: this command can only be used in a tracepoint \"actions\" list."));
5832 add_com ("teval", class_trace, teval_pseudocommand, _("\
5833 Specify one or more expressions to be evaluated at a tracepoint.\n\
5834 Accepts a comma-separated list of (one or more) expressions.\n\
5835 The result of each evaluation will be discarded.\n\
5836 Note: this command can only be used in a tracepoint \"actions\" list."));
5838 add_com ("actions", class_trace, trace_actions_command, _("\
5839 Specify the actions to be taken at a tracepoint.\n\
5840 Tracepoint actions may include collecting of specified data,\n\
5841 single-stepping, or enabling/disabling other tracepoints,\n\
5842 depending on target's capabilities."));
5844 default_collect = xstrdup ("");
5845 add_setshow_string_cmd ("default-collect", class_trace,
5846 &default_collect, _("\
5847 Set the list of expressions to collect by default"), _("\
5848 Show the list of expressions to collect by default"), NULL,
5850 &setlist, &showlist);
5852 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
5853 &disconnected_tracing, _("\
5854 Set whether tracing continues after GDB disconnects."), _("\
5855 Show whether tracing continues after GDB disconnects."), _("\
5856 Use this to continue a tracing run even if GDB disconnects\n\
5857 or detaches from the target. You can reconnect later and look at\n\
5858 trace data collected in the meantime."),
5859 set_disconnected_tracing,
5864 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
5865 &circular_trace_buffer, _("\
5866 Set target's use of circular trace buffer."), _("\
5867 Show target's use of circular trace buffer."), _("\
5868 Use this to make the trace buffer into a circular buffer,\n\
5869 which will discard traceframes (oldest first) instead of filling\n\
5870 up and stopping the trace run."),
5871 set_circular_trace_buffer,
5876 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class,
5877 &trace_buffer_size, _("\
5878 Set requested size of trace buffer."), _("\
5879 Show requested size of trace buffer."), _("\
5880 Use this to choose a size for the trace buffer. Some targets\n\
5881 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
5882 disables any attempt to set the buffer size and lets the target choose."),
5883 set_trace_buffer_size, NULL,
5884 &setlist, &showlist);
5886 add_setshow_string_cmd ("trace-user", class_trace,
5888 Set the user name to use for current and future trace runs"), _("\
5889 Show the user name to use for current and future trace runs"), NULL,
5890 set_trace_user, NULL,
5891 &setlist, &showlist);
5893 add_setshow_string_cmd ("trace-notes", class_trace,
5895 Set notes string to use for current and future trace runs"), _("\
5896 Show the notes string to use for current and future trace runs"), NULL,
5897 set_trace_notes, NULL,
5898 &setlist, &showlist);
5900 add_setshow_string_cmd ("trace-stop-notes", class_trace,
5901 &trace_stop_notes, _("\
5902 Set notes string to use for future tstop commands"), _("\
5903 Show the notes string to use for future tstop commands"), NULL,
5904 set_trace_stop_notes, NULL,
5905 &setlist, &showlist);
5909 add_target_with_completer (&tfile_ops, filename_completer);