1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
25 #include "expression.h"
30 #include "gdb_string.h"
32 #include "breakpoint.h"
33 #include "tracepoint.h"
36 #include "completer.h"
38 #include "dictionary.h"
40 #include "user-regs.h"
44 #include "filenames.h"
45 #include "gdbthread.h"
53 #include "exceptions.h"
54 #include "cli/cli-utils.h"
57 /* readline include files */
58 #include "readline/readline.h"
59 #include "readline/history.h"
61 /* readline defines this. */
72 /* Maximum length of an agent aexpression.
73 This accounts for the fact that packets are limited to 400 bytes
74 (which includes everything -- including the checksum), and assumes
75 the worst case of maximum length for each of the pieces of a
78 NOTE: expressions get mem2hex'ed otherwise this would be twice as
79 large. (400 - 31)/2 == 184 */
80 #define MAX_AGENT_EXPR_LEN 184
84 /* A hook used to notify the UI of tracepoint operations. */
86 void (*deprecated_trace_find_hook) (char *arg, int from_tty);
87 void (*deprecated_trace_start_stop_hook) (int start, int from_tty);
89 extern void (*deprecated_readline_begin_hook) (char *, ...);
90 extern char *(*deprecated_readline_hook) (char *);
91 extern void (*deprecated_readline_end_hook) (void);
96 This module defines the following debugger commands:
97 trace : set a tracepoint on a function, line, or address.
98 info trace : list all debugger-defined tracepoints.
99 delete trace : delete one or more tracepoints.
100 enable trace : enable one or more tracepoints.
101 disable trace : disable one or more tracepoints.
102 actions : specify actions to be taken at a tracepoint.
103 passcount : specify a pass count for a tracepoint.
104 tstart : start a trace experiment.
105 tstop : stop a trace experiment.
106 tstatus : query the status of a trace experiment.
107 tfind : find a trace frame in the trace buffer.
108 tdump : print everything collected at the current tracepoint.
109 save-tracepoints : write tracepoint setup into a file.
111 This module defines the following user-visible debugger variables:
112 $trace_frame : sequence number of trace frame currently being debugged.
113 $trace_line : source line of trace frame currently being debugged.
114 $trace_file : source file of trace frame currently being debugged.
115 $tracepoint : tracepoint number of trace frame currently being debugged.
119 /* ======= Important global variables: ======= */
121 /* The list of all trace state variables. We don't retain pointers to
122 any of these for any reason - API is by name or number only - so it
123 works to have a vector of objects. */
125 typedef struct trace_state_variable tsv_s;
128 /* An object describing the contents of a traceframe. */
130 struct traceframe_info
132 /* Collected memory. */
133 VEC(mem_range_s) *memory;
136 static VEC(tsv_s) *tvariables;
138 /* The next integer to assign to a variable. */
140 static int next_tsv_number = 1;
142 /* Number of last traceframe collected. */
143 static int traceframe_number;
145 /* Tracepoint for last traceframe collected. */
146 static int tracepoint_number;
148 /* Symbol for function for last traceframe collected. */
149 static struct symbol *traceframe_fun;
151 /* Symtab and line for last traceframe collected. */
152 static struct symtab_and_line traceframe_sal;
154 /* The traceframe info of the current traceframe. NULL if we haven't
155 yet attempted to fetch it, or if the target does not support
156 fetching this object, or if we're not inspecting a traceframe
158 static struct traceframe_info *traceframe_info;
160 /* Tracing command lists. */
161 static struct cmd_list_element *tfindlist;
163 /* List of expressions to collect by default at each tracepoint hit. */
164 char *default_collect = "";
166 static int disconnected_tracing;
168 /* This variable controls whether we ask the target for a linear or
169 circular trace buffer. */
171 static int circular_trace_buffer;
173 /* Textual notes applying to the current and/or future trace runs. */
175 char *trace_user = NULL;
177 /* Textual notes applying to the current and/or future trace runs. */
179 char *trace_notes = NULL;
181 /* Textual notes applying to the stopping of a trace. */
183 char *trace_stop_notes = NULL;
185 /* ======= Important command functions: ======= */
186 static void trace_actions_command (char *, int);
187 static void trace_start_command (char *, int);
188 static void trace_stop_command (char *, int);
189 static void trace_status_command (char *, int);
190 static void trace_find_command (char *, int);
191 static void trace_find_pc_command (char *, int);
192 static void trace_find_tracepoint_command (char *, int);
193 static void trace_find_line_command (char *, int);
194 static void trace_find_range_command (char *, int);
195 static void trace_find_outside_command (char *, int);
196 static void trace_dump_command (char *, int);
198 /* support routines */
200 struct collection_list;
201 static void add_aexpr (struct collection_list *, struct agent_expr *);
202 static char *mem2hex (gdb_byte *, char *, int);
203 static void add_register (struct collection_list *collection,
206 static void free_uploaded_tps (struct uploaded_tp **utpp);
207 static void free_uploaded_tsvs (struct uploaded_tsv **utsvp);
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 (char *exp)
611 struct value_print_options opts;
616 /* Call this to borrow the print elements default for collection
618 get_user_print_options (&opts);
623 if (target_supports_string_tracing ())
625 /* Allow an optional decimal number giving an explicit maximum
626 string length, defaulting it to the "print elements" value;
627 so "collect/s80 mystr" gets at most 80 bytes of string. */
628 trace_string_kludge = opts.print_max;
630 if (*exp >= '0' && *exp <= '9')
631 trace_string_kludge = atoi (exp);
632 while (*exp >= '0' && *exp <= '9')
636 error (_("Target does not support \"/s\" option for string tracing."));
639 error (_("Undefined collection format \"%c\"."), *exp);
641 exp = skip_spaces (exp);
646 /* Enter a list of actions for a tracepoint. */
648 trace_actions_command (char *args, int from_tty)
650 struct tracepoint *t;
651 struct command_line *l;
653 t = get_tracepoint_by_number (&args, NULL, 1);
657 xstrprintf ("Enter actions for tracepoint %d, one per line.",
659 struct cleanup *cleanups = make_cleanup (xfree, tmpbuf);
661 l = read_command_lines (tmpbuf, from_tty, 1,
662 check_tracepoint_command, t);
663 do_cleanups (cleanups);
664 breakpoint_set_commands (&t->base, l);
666 /* else just return */
669 /* Report the results of checking the agent expression, as errors or
673 report_agent_reqs_errors (struct agent_expr *aexpr)
675 /* All of the "flaws" are serious bytecode generation issues that
676 should never occur. */
677 if (aexpr->flaw != agent_flaw_none)
678 internal_error (__FILE__, __LINE__, _("expression is malformed"));
680 /* If analysis shows a stack underflow, GDB must have done something
681 badly wrong in its bytecode generation. */
682 if (aexpr->min_height < 0)
683 internal_error (__FILE__, __LINE__,
684 _("expression has min height < 0"));
686 /* Issue this error if the stack is predicted to get too deep. The
687 limit is rather arbitrary; a better scheme might be for the
688 target to report how much stack it will have available. The
689 depth roughly corresponds to parenthesization, so a limit of 20
690 amounts to 20 levels of expression nesting, which is actually
691 a pretty big hairy expression. */
692 if (aexpr->max_height > 20)
693 error (_("Expression is too complicated."));
696 /* worker function */
698 validate_actionline (char **line, struct breakpoint *b)
700 struct cmd_list_element *c;
701 struct expression *exp = NULL;
702 struct cleanup *old_chain = NULL;
704 struct bp_location *loc;
705 struct agent_expr *aexpr;
706 struct tracepoint *t = (struct tracepoint *) b;
708 /* If EOF is typed, *line is NULL. */
712 for (p = *line; isspace ((int) *p);)
715 /* Symbol lookup etc. */
716 if (*p == '\0') /* empty line: just prompt for another line. */
719 if (*p == '#') /* comment line */
722 c = lookup_cmd (&p, cmdlist, "", -1, 1);
724 error (_("`%s' is not a tracepoint action, or is ambiguous."), p);
726 if (cmd_cfunc_eq (c, collect_pseudocommand))
728 trace_string_kludge = 0;
730 p = decode_agent_options (p);
733 { /* Repeat over a comma-separated list. */
734 QUIT; /* Allow user to bail out with ^C. */
735 while (isspace ((int) *p))
738 if (*p == '$') /* Look for special pseudo-symbols. */
740 if (0 == strncasecmp ("reg", p + 1, 3)
741 || 0 == strncasecmp ("arg", p + 1, 3)
742 || 0 == strncasecmp ("loc", p + 1, 3)
743 || 0 == strncasecmp ("_ret", p + 1, 4)
744 || 0 == strncasecmp ("_sdata", p + 1, 6))
749 /* else fall thru, treat p as an expression and parse it! */
752 for (loc = t->base.loc; loc; loc = loc->next)
755 exp = parse_exp_1 (&p, loc->address,
756 block_for_pc (loc->address), 1);
757 old_chain = make_cleanup (free_current_contents, &exp);
759 if (exp->elts[0].opcode == OP_VAR_VALUE)
761 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
763 error (_("constant `%s' (value %s) "
764 "will not be collected."),
765 SYMBOL_PRINT_NAME (exp->elts[2].symbol),
766 plongest (SYMBOL_VALUE (exp->elts[2].symbol)));
768 else if (SYMBOL_CLASS (exp->elts[2].symbol)
769 == LOC_OPTIMIZED_OUT)
771 error (_("`%s' is optimized away "
772 "and cannot be collected."),
773 SYMBOL_PRINT_NAME (exp->elts[2].symbol));
777 /* We have something to collect, make sure that the expr to
778 bytecode translator can handle it and that it's not too
780 aexpr = gen_trace_for_expr (loc->address, exp);
781 make_cleanup_free_agent_expr (aexpr);
783 if (aexpr->len > MAX_AGENT_EXPR_LEN)
784 error (_("Expression is too complicated."));
788 report_agent_reqs_errors (aexpr);
790 do_cleanups (old_chain);
793 while (p && *p++ == ',');
796 else if (cmd_cfunc_eq (c, teval_pseudocommand))
799 { /* Repeat over a comma-separated list. */
800 QUIT; /* Allow user to bail out with ^C. */
801 while (isspace ((int) *p))
805 for (loc = t->base.loc; loc; loc = loc->next)
808 /* Only expressions are allowed for this action. */
809 exp = parse_exp_1 (&p, loc->address,
810 block_for_pc (loc->address), 1);
811 old_chain = make_cleanup (free_current_contents, &exp);
813 /* We have something to evaluate, make sure that the expr to
814 bytecode translator can handle it and that it's not too
816 aexpr = gen_eval_for_expr (loc->address, exp);
817 make_cleanup_free_agent_expr (aexpr);
819 if (aexpr->len > MAX_AGENT_EXPR_LEN)
820 error (_("Expression is too complicated."));
823 report_agent_reqs_errors (aexpr);
825 do_cleanups (old_chain);
828 while (p && *p++ == ',');
831 else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
833 char *steparg; /* In case warning is necessary. */
835 while (isspace ((int) *p))
839 if (*p == '\0' || (t->step_count = strtol (p, &p, 0)) == 0)
840 error (_("while-stepping step count `%s' is malformed."), *line);
843 else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
847 error (_("`%s' is not a supported tracepoint action."), *line);
851 memrange_absolute = -1
856 int type; /* memrange_absolute for absolute memory range,
857 else basereg number. */
858 bfd_signed_vma start;
862 struct collection_list
864 unsigned char regs_mask[32]; /* room for up to 256 regs */
867 struct memrange *list;
868 long aexpr_listsize; /* size of array pointed to by expr_list elt */
870 struct agent_expr **aexpr_list;
872 /* True is the user requested a collection of "$_sdata", "static
876 tracepoint_list, stepping_list;
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,
992 bfd_signed_vma offset;
993 int treat_as_expr = 0;
995 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
996 switch (SYMBOL_CLASS (sym))
999 printf_filtered ("%s: don't know symbol class %d\n",
1000 SYMBOL_PRINT_NAME (sym),
1001 SYMBOL_CLASS (sym));
1004 printf_filtered ("constant %s (value %s) will not be collected.\n",
1005 SYMBOL_PRINT_NAME (sym), plongest (SYMBOL_VALUE (sym)));
1008 offset = SYMBOL_VALUE_ADDRESS (sym);
1013 sprintf_vma (tmp, offset);
1014 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1015 SYMBOL_PRINT_NAME (sym), len,
1018 /* A struct may be a C++ class with static fields, go to general
1019 expression handling. */
1020 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
1023 add_memrange (collect, memrange_absolute, offset, len);
1026 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
1028 printf_filtered ("LOC_REG[parm] %s: ",
1029 SYMBOL_PRINT_NAME (sym));
1030 add_register (collect, reg);
1031 /* Check for doubles stored in two registers. */
1032 /* FIXME: how about larger types stored in 3 or more regs? */
1033 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
1034 len > register_size (gdbarch, reg))
1035 add_register (collect, reg + 1);
1038 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1039 printf_filtered (" (will not collect %s)\n",
1040 SYMBOL_PRINT_NAME (sym));
1044 offset = frame_offset + SYMBOL_VALUE (sym);
1047 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1048 SYMBOL_PRINT_NAME (sym), len);
1049 printf_vma (offset);
1050 printf_filtered (" from frame ptr reg %d\n", reg);
1052 add_memrange (collect, reg, offset, len);
1054 case LOC_REGPARM_ADDR:
1055 reg = SYMBOL_VALUE (sym);
1059 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1060 SYMBOL_PRINT_NAME (sym), len);
1061 printf_vma (offset);
1062 printf_filtered (" from reg %d\n", reg);
1064 add_memrange (collect, reg, offset, len);
1068 offset = frame_offset + SYMBOL_VALUE (sym);
1071 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1072 SYMBOL_PRINT_NAME (sym), len);
1073 printf_vma (offset);
1074 printf_filtered (" from frame ptr reg %d\n", reg);
1076 add_memrange (collect, reg, offset, len);
1079 case LOC_UNRESOLVED:
1083 case LOC_OPTIMIZED_OUT:
1084 printf_filtered ("%s has been optimized out of existence.\n",
1085 SYMBOL_PRINT_NAME (sym));
1093 /* Expressions are the most general case. */
1096 struct agent_expr *aexpr;
1097 struct cleanup *old_chain1 = NULL;
1099 aexpr = gen_trace_for_var (scope, gdbarch, sym);
1101 /* It can happen that the symbol is recorded as a computed
1102 location, but it's been optimized away and doesn't actually
1103 have a location expression. */
1106 printf_filtered ("%s has been optimized out of existence.\n",
1107 SYMBOL_PRINT_NAME (sym));
1111 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1115 report_agent_reqs_errors (aexpr);
1117 discard_cleanups (old_chain1);
1118 add_aexpr (collect, aexpr);
1120 /* Take care of the registers. */
1121 if (aexpr->reg_mask_len > 0)
1125 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1127 QUIT; /* Allow user to bail out with ^C. */
1128 if (aexpr->reg_mask[ndx1] != 0)
1130 /* Assume chars have 8 bits. */
1131 for (ndx2 = 0; ndx2 < 8; ndx2++)
1132 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1133 /* It's used -- record it. */
1134 add_register (collect, ndx1 * 8 + ndx2);
1141 /* Data to be passed around in the calls to the locals and args
1144 struct add_local_symbols_data
1146 struct collection_list *collect;
1147 struct gdbarch *gdbarch;
1154 /* The callback for the locals and args iterators. */
1157 do_collect_symbol (const char *print_name,
1161 struct add_local_symbols_data *p = cb_data;
1163 collect_symbol (p->collect, sym, p->gdbarch, p->frame_regno,
1164 p->frame_offset, p->pc);
1168 /* Add all locals (or args) symbols to collection list. */
1170 add_local_symbols (struct collection_list *collect,
1171 struct gdbarch *gdbarch, CORE_ADDR pc,
1172 long frame_regno, long frame_offset, int type)
1174 struct block *block;
1175 struct add_local_symbols_data cb_data;
1177 cb_data.collect = collect;
1178 cb_data.gdbarch = gdbarch;
1180 cb_data.frame_regno = frame_regno;
1181 cb_data.frame_offset = frame_offset;
1186 block = block_for_pc (pc);
1189 warning (_("Can't collect locals; "
1190 "no symbol table info available.\n"));
1194 iterate_over_block_local_vars (block, do_collect_symbol, &cb_data);
1195 if (cb_data.count == 0)
1196 warning (_("No locals found in scope."));
1200 pc = get_pc_function_start (pc);
1201 block = block_for_pc (pc);
1204 warning (_("Can't collect args; no symbol table info available."));
1208 iterate_over_block_arg_vars (block, do_collect_symbol, &cb_data);
1209 if (cb_data.count == 0)
1210 warning (_("No args found in scope."));
1215 add_static_trace_data (struct collection_list *collection)
1218 printf_filtered ("collect static trace data\n");
1219 collection->strace_data = 1;
1222 /* worker function */
1224 clear_collection_list (struct collection_list *list)
1228 list->next_memrange = 0;
1229 for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1231 free_agent_expr (list->aexpr_list[ndx]);
1232 list->aexpr_list[ndx] = NULL;
1234 list->next_aexpr_elt = 0;
1235 memset (list->regs_mask, 0, sizeof (list->regs_mask));
1236 list->strace_data = 0;
1239 /* Reduce a collection list to string form (for gdb protocol). */
1241 stringify_collection_list (struct collection_list *list, char *string)
1243 char temp_buf[2048];
1247 char *(*str_list)[];
1251 count = 1 + 1 + list->next_memrange + list->next_aexpr_elt + 1;
1252 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1254 if (list->strace_data)
1257 printf_filtered ("\nCollecting static trace data\n");
1260 (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
1264 for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1265 if (list->regs_mask[i] != 0) /* Skip leading zeroes in regs_mask. */
1267 if (list->regs_mask[i] != 0) /* Prepare to send regs_mask to the stub. */
1270 printf_filtered ("\nCollecting registers (mask): 0x");
1275 QUIT; /* Allow user to bail out with ^C. */
1277 printf_filtered ("%02X", list->regs_mask[i]);
1278 sprintf (end, "%02X", list->regs_mask[i]);
1281 (*str_list)[ndx] = xstrdup (temp_buf);
1285 printf_filtered ("\n");
1286 if (list->next_memrange > 0 && info_verbose)
1287 printf_filtered ("Collecting memranges: \n");
1288 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1290 QUIT; /* Allow user to bail out with ^C. */
1291 sprintf_vma (tmp2, list->list[i].start);
1294 printf_filtered ("(%d, %s, %ld)\n",
1297 (long) (list->list[i].end - list->list[i].start));
1299 if (count + 27 > MAX_AGENT_EXPR_LEN)
1301 (*str_list)[ndx] = savestring (temp_buf, count);
1308 bfd_signed_vma length = list->list[i].end - list->list[i].start;
1310 /* The "%X" conversion specifier expects an unsigned argument,
1311 so passing -1 (memrange_absolute) to it directly gives you
1312 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1314 if (list->list[i].type == memrange_absolute)
1315 sprintf (end, "M-1,%s,%lX", tmp2, (long) length);
1317 sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length);
1320 count += strlen (end);
1321 end = temp_buf + count;
1324 for (i = 0; i < list->next_aexpr_elt; i++)
1326 QUIT; /* Allow user to bail out with ^C. */
1327 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1329 (*str_list)[ndx] = savestring (temp_buf, count);
1334 sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1335 end += 10; /* 'X' + 8 hex digits + ',' */
1338 end = mem2hex (list->aexpr_list[i]->buf,
1339 end, list->aexpr_list[i]->len);
1340 count += 2 * list->aexpr_list[i]->len;
1345 (*str_list)[ndx] = savestring (temp_buf, count);
1350 (*str_list)[ndx] = NULL;
1363 encode_actions_1 (struct command_line *action,
1364 struct breakpoint *t,
1365 struct bp_location *tloc,
1367 LONGEST frame_offset,
1368 struct collection_list *collect,
1369 struct collection_list *stepping_list)
1372 struct expression *exp = NULL;
1374 struct value *tempval;
1375 struct cmd_list_element *cmd;
1376 struct agent_expr *aexpr;
1378 for (; action; action = action->next)
1380 QUIT; /* Allow user to bail out with ^C. */
1381 action_exp = action->line;
1382 while (isspace ((int) *action_exp))
1385 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1387 error (_("Bad action list item: %s"), action_exp);
1389 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1391 trace_string_kludge = 0;
1392 if (*action_exp == '/')
1393 action_exp = decode_agent_options (action_exp);
1396 { /* Repeat over a comma-separated list. */
1397 QUIT; /* Allow user to bail out with ^C. */
1398 while (isspace ((int) *action_exp))
1401 if (0 == strncasecmp ("$reg", action_exp, 4))
1403 for (i = 0; i < gdbarch_num_regs (tloc->gdbarch); i++)
1404 add_register (collect, i);
1405 action_exp = strchr (action_exp, ','); /* more? */
1407 else if (0 == strncasecmp ("$arg", action_exp, 4))
1409 add_local_symbols (collect,
1415 action_exp = strchr (action_exp, ','); /* more? */
1417 else if (0 == strncasecmp ("$loc", action_exp, 4))
1419 add_local_symbols (collect,
1425 action_exp = strchr (action_exp, ','); /* more? */
1427 else if (0 == strncasecmp ("$_ret", action_exp, 5))
1429 struct cleanup *old_chain1 = NULL;
1431 aexpr = gen_trace_for_return_address (tloc->address,
1434 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1437 report_agent_reqs_errors (aexpr);
1439 discard_cleanups (old_chain1);
1440 add_aexpr (collect, aexpr);
1442 /* take care of the registers */
1443 if (aexpr->reg_mask_len > 0)
1447 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1449 QUIT; /* allow user to bail out with ^C */
1450 if (aexpr->reg_mask[ndx1] != 0)
1452 /* assume chars have 8 bits */
1453 for (ndx2 = 0; ndx2 < 8; ndx2++)
1454 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1455 /* it's used -- record it */
1456 add_register (collect,
1462 action_exp = strchr (action_exp, ','); /* more? */
1464 else if (0 == strncasecmp ("$_sdata", action_exp, 7))
1466 add_static_trace_data (collect);
1467 action_exp = strchr (action_exp, ','); /* more? */
1472 struct cleanup *old_chain = NULL;
1473 struct cleanup *old_chain1 = NULL;
1475 exp = parse_exp_1 (&action_exp, tloc->address,
1476 block_for_pc (tloc->address), 1);
1477 old_chain = make_cleanup (free_current_contents, &exp);
1479 switch (exp->elts[0].opcode)
1483 const char *name = &exp->elts[2].string;
1485 i = user_reg_map_name_to_regnum (tloc->gdbarch,
1486 name, strlen (name));
1488 internal_error (__FILE__, __LINE__,
1489 _("Register $%s not available"),
1492 printf_filtered ("OP_REGISTER: ");
1493 add_register (collect, i);
1498 /* Safe because we know it's a simple expression. */
1499 tempval = evaluate_expression (exp);
1500 addr = value_address (tempval);
1501 /* Initialize the TYPE_LENGTH if it is a typedef. */
1502 check_typedef (exp->elts[1].type);
1503 add_memrange (collect, memrange_absolute, addr,
1504 TYPE_LENGTH (exp->elts[1].type));
1508 collect_symbol (collect,
1509 exp->elts[2].symbol,
1516 default: /* Full-fledged expression. */
1517 aexpr = gen_trace_for_expr (tloc->address, exp);
1519 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1523 report_agent_reqs_errors (aexpr);
1525 discard_cleanups (old_chain1);
1526 add_aexpr (collect, aexpr);
1528 /* Take care of the registers. */
1529 if (aexpr->reg_mask_len > 0)
1534 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1536 QUIT; /* Allow user to bail out with ^C. */
1537 if (aexpr->reg_mask[ndx1] != 0)
1539 /* Assume chars have 8 bits. */
1540 for (ndx2 = 0; ndx2 < 8; ndx2++)
1541 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1542 /* It's used -- record it. */
1543 add_register (collect,
1550 do_cleanups (old_chain);
1553 while (action_exp && *action_exp++ == ',');
1555 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1558 { /* Repeat over a comma-separated list. */
1559 QUIT; /* Allow user to bail out with ^C. */
1560 while (isspace ((int) *action_exp))
1564 struct cleanup *old_chain = NULL;
1565 struct cleanup *old_chain1 = NULL;
1567 exp = parse_exp_1 (&action_exp, tloc->address,
1568 block_for_pc (tloc->address), 1);
1569 old_chain = make_cleanup (free_current_contents, &exp);
1571 aexpr = gen_eval_for_expr (tloc->address, exp);
1572 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1575 report_agent_reqs_errors (aexpr);
1577 discard_cleanups (old_chain1);
1578 /* Even though we're not officially collecting, add
1579 to the collect list anyway. */
1580 add_aexpr (collect, aexpr);
1582 do_cleanups (old_chain);
1585 while (action_exp && *action_exp++ == ',');
1587 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1589 /* We check against nested while-stepping when setting
1590 breakpoint action, so no way to run into nested
1592 gdb_assert (stepping_list);
1594 encode_actions_1 (action->body_list[0], t, tloc, frame_reg,
1595 frame_offset, stepping_list, NULL);
1598 error (_("Invalid tracepoint command '%s'"), action->line);
1602 /* Render all actions into gdb protocol. */
1605 encode_actions (struct breakpoint *t, struct bp_location *tloc,
1606 char ***tdp_actions, char ***stepping_actions)
1608 static char tdp_buff[2048], step_buff[2048];
1609 char *default_collect_line = NULL;
1610 struct command_line *actions;
1611 struct command_line *default_collect_action = NULL;
1613 LONGEST frame_offset;
1614 struct cleanup *back_to;
1616 back_to = make_cleanup (null_cleanup, NULL);
1618 clear_collection_list (&tracepoint_list);
1619 clear_collection_list (&stepping_list);
1621 *tdp_actions = NULL;
1622 *stepping_actions = NULL;
1624 gdbarch_virtual_frame_pointer (tloc->gdbarch,
1625 tloc->address, &frame_reg, &frame_offset);
1627 actions = breakpoint_commands (t);
1629 /* If there are default expressions to collect, make up a collect
1630 action and prepend to the action list to encode. Note that since
1631 validation is per-tracepoint (local var "xyz" might be valid for
1632 one tracepoint and not another, etc), we make up the action on
1633 the fly, and don't cache it. */
1634 if (*default_collect)
1638 default_collect_line = xstrprintf ("collect %s", default_collect);
1639 make_cleanup (xfree, default_collect_line);
1641 line = default_collect_line;
1642 validate_actionline (&line, t);
1644 default_collect_action = xmalloc (sizeof (struct command_line));
1645 make_cleanup (xfree, default_collect_action);
1646 default_collect_action->next = actions;
1647 default_collect_action->line = line;
1648 actions = default_collect_action;
1650 encode_actions_1 (actions, t, tloc, frame_reg, frame_offset,
1651 &tracepoint_list, &stepping_list);
1653 memrange_sortmerge (&tracepoint_list);
1654 memrange_sortmerge (&stepping_list);
1656 *tdp_actions = stringify_collection_list (&tracepoint_list,
1658 *stepping_actions = stringify_collection_list (&stepping_list,
1661 do_cleanups (back_to);
1665 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
1667 if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1669 collect->aexpr_list =
1670 xrealloc (collect->aexpr_list,
1671 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
1672 collect->aexpr_listsize *= 2;
1674 collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1675 collect->next_aexpr_elt++;
1679 process_tracepoint_on_disconnect (void)
1681 VEC(breakpoint_p) *tp_vec = NULL;
1683 struct breakpoint *b;
1684 int has_pending_p = 0;
1686 /* Check whether we still have pending tracepoint. If we have, warn the
1687 user that pending tracepoint will no longer work. */
1688 tp_vec = all_tracepoints ();
1689 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1698 struct bp_location *loc1;
1700 for (loc1 = b->loc; loc1; loc1 = loc1->next)
1702 if (loc1->shlib_disabled)
1713 VEC_free (breakpoint_p, tp_vec);
1716 warning (_("Pending tracepoints will not be resolved while"
1717 " GDB is disconnected\n"));
1722 start_tracing (char *notes)
1724 VEC(breakpoint_p) *tp_vec = NULL;
1726 struct breakpoint *b;
1727 struct trace_state_variable *tsv;
1728 int any_enabled = 0, num_to_download = 0;
1731 tp_vec = all_tracepoints ();
1733 /* No point in tracing without any tracepoints... */
1734 if (VEC_length (breakpoint_p, tp_vec) == 0)
1736 VEC_free (breakpoint_p, tp_vec);
1737 error (_("No tracepoints defined, not starting trace"));
1740 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1742 struct tracepoint *t = (struct tracepoint *) b;
1743 struct bp_location *loc;
1745 if (b->enable_state == bp_enabled)
1748 if ((b->type == bp_fast_tracepoint
1749 ? may_insert_fast_tracepoints
1750 : may_insert_tracepoints))
1753 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1754 (b->type == bp_fast_tracepoint ? "fast " : ""), b->number);
1759 if (target_supports_enable_disable_tracepoint ())
1760 warning (_("No tracepoints enabled"));
1763 /* No point in tracing with only disabled tracepoints that
1764 cannot be re-enabled. */
1765 VEC_free (breakpoint_p, tp_vec);
1766 error (_("No tracepoints enabled, not starting trace"));
1770 if (num_to_download <= 0)
1772 VEC_free (breakpoint_p, tp_vec);
1773 error (_("No tracepoints that may be downloaded, not starting trace"));
1776 target_trace_init ();
1778 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1780 struct tracepoint *t = (struct tracepoint *) b;
1781 struct bp_location *loc;
1782 int bp_location_downloaded = 0;
1784 /* Clear `inserted' flag. */
1785 for (loc = b->loc; loc; loc = loc->next)
1788 if ((b->type == bp_fast_tracepoint
1789 ? !may_insert_fast_tracepoints
1790 : !may_insert_tracepoints))
1793 t->number_on_target = 0;
1795 for (loc = b->loc; loc; loc = loc->next)
1797 /* Since tracepoint locations are never duplicated, `inserted'
1798 flag should be zero. */
1799 gdb_assert (!loc->inserted);
1801 target_download_tracepoint (loc);
1804 bp_location_downloaded = 1;
1807 t->number_on_target = b->number;
1809 for (loc = b->loc; loc; loc = loc->next)
1810 if (loc->probe != NULL)
1811 loc->probe->pops->set_semaphore (loc->probe, loc->gdbarch);
1813 if (bp_location_downloaded)
1814 observer_notify_breakpoint_modified (b);
1816 VEC_free (breakpoint_p, tp_vec);
1818 /* Send down all the trace state variables too. */
1819 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1821 target_download_trace_state_variable (tsv);
1824 /* Tell target to treat text-like sections as transparent. */
1825 target_trace_set_readonly_regions ();
1826 /* Set some mode flags. */
1827 target_set_disconnected_tracing (disconnected_tracing);
1828 target_set_circular_trace_buffer (circular_trace_buffer);
1831 notes = trace_notes;
1832 ret = target_set_trace_notes (trace_user, notes, NULL);
1834 if (!ret && (trace_user || notes))
1835 warning (_("Target does not support trace user/notes, info ignored"));
1837 /* Now insert traps and begin collecting data. */
1838 target_trace_start ();
1840 /* Reset our local state. */
1841 set_traceframe_num (-1);
1842 set_tracepoint_num (-1);
1843 set_traceframe_context (NULL);
1844 current_trace_status()->running = 1;
1845 clear_traceframe_info ();
1848 /* The tstart command requests the target to start a new trace run.
1849 The command passes any arguments it has to the target verbatim, as
1850 an optional "trace note". This is useful as for instance a warning
1851 to other users if the trace runs disconnected, and you don't want
1852 anybody else messing with the target. */
1855 trace_start_command (char *args, int from_tty)
1857 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1859 if (current_trace_status ()->running)
1862 && !query (_("A trace is running already. Start a new run? ")))
1863 error (_("New trace run not started."));
1866 start_tracing (args);
1869 /* The tstop command stops the tracing run. The command passes any
1870 supplied arguments to the target verbatim as a "stop note"; if the
1871 target supports trace notes, then it will be reported back as part
1872 of the trace run's status. */
1875 trace_stop_command (char *args, int from_tty)
1877 if (!current_trace_status ()->running)
1878 error (_("Trace is not running."));
1880 stop_tracing (args);
1884 stop_tracing (char *note)
1887 VEC(breakpoint_p) *tp_vec = NULL;
1889 struct breakpoint *t;
1891 target_trace_stop ();
1893 tp_vec = all_tracepoints ();
1894 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1896 struct bp_location *loc;
1898 if ((t->type == bp_fast_tracepoint
1899 ? !may_insert_fast_tracepoints
1900 : !may_insert_tracepoints))
1903 for (loc = t->loc; loc; loc = loc->next)
1905 /* GDB can be totally absent in some disconnected trace scenarios,
1906 but we don't really care if this semaphore goes out of sync.
1907 That's why we are decrementing it here, but not taking care
1909 if (loc->probe != NULL)
1910 loc->probe->pops->clear_semaphore (loc->probe, loc->gdbarch);
1914 VEC_free (breakpoint_p, tp_vec);
1917 note = trace_stop_notes;
1918 ret = target_set_trace_notes (NULL, NULL, note);
1921 warning (_("Target does not support trace notes, note ignored"));
1923 /* Should change in response to reply? */
1924 current_trace_status ()->running = 0;
1927 /* tstatus command */
1929 trace_status_command (char *args, int from_tty)
1931 struct trace_status *ts = current_trace_status ();
1933 VEC(breakpoint_p) *tp_vec = NULL;
1934 struct breakpoint *t;
1936 status = target_get_trace_status (ts);
1940 if (ts->filename != NULL)
1941 printf_filtered (_("Using a trace file.\n"));
1944 printf_filtered (_("Trace can not be run on this target.\n"));
1949 if (!ts->running_known)
1951 printf_filtered (_("Run/stop status is unknown.\n"));
1953 else if (ts->running)
1955 printf_filtered (_("Trace is running on the target.\n"));
1959 switch (ts->stop_reason)
1961 case trace_never_run:
1962 printf_filtered (_("No trace has been run on the target.\n"));
1966 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1969 printf_filtered (_("Trace stopped by a tstop command.\n"));
1971 case trace_buffer_full:
1972 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1974 case trace_disconnected:
1975 printf_filtered (_("Trace stopped because of disconnection.\n"));
1977 case tracepoint_passcount:
1978 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1979 ts->stopping_tracepoint);
1981 case tracepoint_error:
1982 if (ts->stopping_tracepoint)
1983 printf_filtered (_("Trace stopped by an "
1984 "error (%s, tracepoint %d).\n"),
1985 ts->stop_desc, ts->stopping_tracepoint);
1987 printf_filtered (_("Trace stopped by an error (%s).\n"),
1990 case trace_stop_reason_unknown:
1991 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1994 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
2000 if (ts->traceframes_created >= 0
2001 && ts->traceframe_count != ts->traceframes_created)
2003 printf_filtered (_("Buffer contains %d trace "
2004 "frames (of %d created total).\n"),
2005 ts->traceframe_count, ts->traceframes_created);
2007 else if (ts->traceframe_count >= 0)
2009 printf_filtered (_("Collected %d trace frames.\n"),
2010 ts->traceframe_count);
2013 if (ts->buffer_free >= 0)
2015 if (ts->buffer_size >= 0)
2017 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2018 ts->buffer_free, ts->buffer_size);
2019 if (ts->buffer_size > 0)
2020 printf_filtered (_(" (%d%% full)"),
2021 ((int) ((((long long) (ts->buffer_size
2022 - ts->buffer_free)) * 100)
2023 / ts->buffer_size)));
2024 printf_filtered (_(".\n"));
2027 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2031 if (ts->disconnected_tracing)
2032 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2034 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2036 if (ts->circular_buffer)
2037 printf_filtered (_("Trace buffer is circular.\n"));
2039 if (ts->user_name && strlen (ts->user_name) > 0)
2040 printf_filtered (_("Trace user is %s.\n"), ts->user_name);
2042 if (ts->notes && strlen (ts->notes) > 0)
2043 printf_filtered (_("Trace notes: %s.\n"), ts->notes);
2045 /* Now report on what we're doing with tfind. */
2046 if (traceframe_number >= 0)
2047 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2048 traceframe_number, tracepoint_number);
2050 printf_filtered (_("Not looking at any trace frame.\n"));
2052 /* Report start/stop times if supplied. */
2057 LONGEST run_time = ts->stop_time - ts->start_time;
2059 /* Reporting a run time is more readable than two long numbers. */
2060 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2061 (long int) ts->start_time / 1000000,
2062 (long int) ts->start_time % 1000000,
2063 (long int) run_time / 1000000,
2064 (long int) run_time % 1000000);
2067 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2068 (long int) ts->start_time / 1000000,
2069 (long int) ts->start_time % 1000000);
2071 else if (ts->stop_time)
2072 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2073 (long int) ts->stop_time / 1000000,
2074 (long int) ts->stop_time % 1000000);
2076 /* Now report any per-tracepoint status available. */
2077 tp_vec = all_tracepoints ();
2079 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
2080 target_get_tracepoint_status (t, NULL);
2082 VEC_free (breakpoint_p, tp_vec);
2085 /* Report the trace status to uiout, in a way suitable for MI, and not
2086 suitable for CLI. If ON_STOP is true, suppress a few fields that
2087 are not meaningful in the -trace-stop response.
2089 The implementation is essentially parallel to trace_status_command, but
2090 merging them will result in unreadable code. */
2092 trace_status_mi (int on_stop)
2094 struct ui_out *uiout = current_uiout;
2095 struct trace_status *ts = current_trace_status ();
2098 status = target_get_trace_status (ts);
2100 if (status == -1 && ts->filename == NULL)
2102 ui_out_field_string (uiout, "supported", "0");
2106 if (ts->filename != NULL)
2107 ui_out_field_string (uiout, "supported", "file");
2109 ui_out_field_string (uiout, "supported", "1");
2111 if (ts->filename != NULL)
2112 ui_out_field_string (uiout, "trace-file", ts->filename);
2114 gdb_assert (ts->running_known);
2118 ui_out_field_string (uiout, "running", "1");
2120 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2121 Given that the frontend gets the status either on -trace-stop, or from
2122 -trace-status after re-connection, it does not seem like this
2123 information is necessary for anything. It is not necessary for either
2124 figuring the vital state of the target nor for navigation of trace
2125 frames. If the frontend wants to show the current state is some
2126 configure dialog, it can request the value when such dialog is
2127 invoked by the user. */
2131 char *stop_reason = NULL;
2132 int stopping_tracepoint = -1;
2135 ui_out_field_string (uiout, "running", "0");
2137 if (ts->stop_reason != trace_stop_reason_unknown)
2139 switch (ts->stop_reason)
2142 stop_reason = "request";
2144 case trace_buffer_full:
2145 stop_reason = "overflow";
2147 case trace_disconnected:
2148 stop_reason = "disconnection";
2150 case tracepoint_passcount:
2151 stop_reason = "passcount";
2152 stopping_tracepoint = ts->stopping_tracepoint;
2154 case tracepoint_error:
2155 stop_reason = "error";
2156 stopping_tracepoint = ts->stopping_tracepoint;
2162 ui_out_field_string (uiout, "stop-reason", stop_reason);
2163 if (stopping_tracepoint != -1)
2164 ui_out_field_int (uiout, "stopping-tracepoint",
2165 stopping_tracepoint);
2166 if (ts->stop_reason == tracepoint_error)
2167 ui_out_field_string (uiout, "error-description",
2173 if (ts->traceframe_count != -1)
2174 ui_out_field_int (uiout, "frames", ts->traceframe_count);
2175 if (ts->traceframes_created != -1)
2176 ui_out_field_int (uiout, "frames-created", ts->traceframes_created);
2177 if (ts->buffer_size != -1)
2178 ui_out_field_int (uiout, "buffer-size", ts->buffer_size);
2179 if (ts->buffer_free != -1)
2180 ui_out_field_int (uiout, "buffer-free", ts->buffer_free);
2182 ui_out_field_int (uiout, "disconnected", ts->disconnected_tracing);
2183 ui_out_field_int (uiout, "circular", ts->circular_buffer);
2185 ui_out_field_string (uiout, "user-name", ts->user_name);
2186 ui_out_field_string (uiout, "notes", ts->notes);
2191 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2192 (long int) ts->start_time / 1000000,
2193 (long int) ts->start_time % 1000000);
2194 ui_out_field_string (uiout, "start-time", buf);
2195 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2196 (long int) ts->stop_time / 1000000,
2197 (long int) ts->stop_time % 1000000);
2198 ui_out_field_string (uiout, "stop-time", buf);
2202 /* This function handles the details of what to do about an ongoing
2203 tracing run if the user has asked to detach or otherwise disconnect
2206 disconnect_tracing (int from_tty)
2208 /* It can happen that the target that was tracing went away on its
2209 own, and we didn't notice. Get a status update, and if the
2210 current target doesn't even do tracing, then assume it's not
2212 if (target_get_trace_status (current_trace_status ()) < 0)
2213 current_trace_status ()->running = 0;
2215 /* If running interactively, give the user the option to cancel and
2216 then decide what to do differently with the run. Scripts are
2217 just going to disconnect and let the target deal with it,
2218 according to how it's been instructed previously via
2219 disconnected-tracing. */
2220 if (current_trace_status ()->running && from_tty)
2222 process_tracepoint_on_disconnect ();
2224 if (current_trace_status ()->disconnected_tracing)
2226 if (!query (_("Trace is running and will "
2227 "continue after detach; detach anyway? ")))
2228 error (_("Not confirmed."));
2232 if (!query (_("Trace is running but will "
2233 "stop on detach; detach anyway? ")))
2234 error (_("Not confirmed."));
2238 /* Also we want to be out of tfind mode, otherwise things can get
2239 confusing upon reconnection. Just use these calls instead of
2240 full tfind_1 behavior because we're in the middle of detaching,
2241 and there's no point to updating current stack frame etc. */
2242 set_current_traceframe (-1);
2243 set_tracepoint_num (-1);
2244 set_traceframe_context (NULL);
2247 /* Worker function for the various flavors of the tfind command. */
2249 tfind_1 (enum trace_find_type type, int num,
2250 ULONGEST addr1, ULONGEST addr2,
2253 int target_frameno = -1, target_tracept = -1;
2254 struct frame_id old_frame_id = null_frame_id;
2255 struct tracepoint *tp;
2256 struct ui_out *uiout = current_uiout;
2258 /* Only try to get the current stack frame if we have a chance of
2259 succeeding. In particular, if we're trying to get a first trace
2260 frame while all threads are running, it's not going to succeed,
2261 so leave it with a default value and let the frame comparison
2262 below (correctly) decide to print out the source location of the
2264 if (!(type == tfind_number && num == -1)
2265 && (has_stack_frames () || traceframe_number >= 0))
2266 old_frame_id = get_frame_id (get_current_frame ());
2268 target_frameno = target_trace_find (type, num, addr1, addr2,
2271 if (type == tfind_number
2273 && target_frameno == -1)
2275 /* We told the target to get out of tfind mode, and it did. */
2277 else if (target_frameno == -1)
2279 /* A request for a non-existent trace frame has failed.
2280 Our response will be different, depending on FROM_TTY:
2282 If FROM_TTY is true, meaning that this command was
2283 typed interactively by the user, then give an error
2284 and DO NOT change the state of traceframe_number etc.
2286 However if FROM_TTY is false, meaning that we're either
2287 in a script, a loop, or a user-defined command, then
2288 DON'T give an error, but DO change the state of
2289 traceframe_number etc. to invalid.
2291 The rationalle is that if you typed the command, you
2292 might just have committed a typo or something, and you'd
2293 like to NOT lose your current debugging state. However
2294 if you're in a user-defined command or especially in a
2295 loop, then you need a way to detect that the command
2296 failed WITHOUT aborting. This allows you to write
2297 scripts that search thru the trace buffer until the end,
2298 and then continue on to do something else. */
2301 error (_("Target failed to find requested trace frame."));
2305 printf_filtered ("End of trace buffer.\n");
2306 #if 0 /* dubious now? */
2307 /* The following will not recurse, since it's
2309 trace_find_command ("-1", from_tty);
2314 tp = get_tracepoint_by_number_on_target (target_tracept);
2316 reinit_frame_cache ();
2317 target_dcache_invalidate ();
2319 set_tracepoint_num (tp ? tp->base.number : target_tracept);
2321 if (target_frameno != get_traceframe_number ())
2322 observer_notify_traceframe_changed (target_frameno, tracepoint_number);
2324 set_current_traceframe (target_frameno);
2326 if (target_frameno == -1)
2327 set_traceframe_context (NULL);
2329 set_traceframe_context (get_current_frame ());
2331 if (traceframe_number >= 0)
2333 /* Use different branches for MI and CLI to make CLI messages
2335 if (ui_out_is_mi_like_p (uiout))
2337 ui_out_field_string (uiout, "found", "1");
2338 ui_out_field_int (uiout, "tracepoint", tracepoint_number);
2339 ui_out_field_int (uiout, "traceframe", traceframe_number);
2343 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2344 traceframe_number, tracepoint_number);
2349 if (ui_out_is_mi_like_p (uiout))
2350 ui_out_field_string (uiout, "found", "0");
2351 else if (type == tfind_number && num == -1)
2352 printf_unfiltered (_("No longer looking at any trace frame\n"));
2353 else /* This case may never occur, check. */
2354 printf_unfiltered (_("No trace frame found\n"));
2357 /* If we're in nonstop mode and getting out of looking at trace
2358 frames, there won't be any current frame to go back to and
2361 && (has_stack_frames () || traceframe_number >= 0))
2363 enum print_what print_what;
2365 /* NOTE: in imitation of the step command, try to determine
2366 whether we have made a transition from one function to
2367 another. If so, we'll print the "stack frame" (ie. the new
2368 function and it's arguments) -- otherwise we'll just show the
2371 if (frame_id_eq (old_frame_id,
2372 get_frame_id (get_current_frame ())))
2373 print_what = SRC_LINE;
2375 print_what = SRC_AND_LOC;
2377 print_stack_frame (get_selected_frame (NULL), 1, print_what);
2382 /* trace_find_command takes a trace frame number n,
2383 sends "QTFrame:<n>" to the target,
2384 and accepts a reply that may contain several optional pieces
2385 of information: a frame number, a tracepoint number, and an
2386 indication of whether this is a trap frame or a stepping frame.
2388 The minimal response is just "OK" (which indicates that the
2389 target does not give us a frame number or a tracepoint number).
2390 Instead of that, the target may send us a string containing
2392 F<hexnum> (gives the selected frame number)
2393 T<hexnum> (gives the selected tracepoint number)
2398 trace_find_command (char *args, int from_tty)
2399 { /* This should only be called with a numeric argument. */
2402 if (current_trace_status ()->running
2403 && current_trace_status ()->filename == NULL)
2404 error (_("May not look at trace frames while trace is running."));
2406 if (args == 0 || *args == 0)
2407 { /* TFIND with no args means find NEXT trace frame. */
2408 if (traceframe_number == -1)
2409 frameno = 0; /* "next" is first one. */
2411 frameno = traceframe_number + 1;
2413 else if (0 == strcmp (args, "-"))
2415 if (traceframe_number == -1)
2416 error (_("not debugging trace buffer"));
2417 else if (from_tty && traceframe_number == 0)
2418 error (_("already at start of trace buffer"));
2420 frameno = traceframe_number - 1;
2422 /* A hack to work around eval's need for fp to have been collected. */
2423 else if (0 == strcmp (args, "-1"))
2426 frameno = parse_and_eval_long (args);
2429 error (_("invalid input (%d is less than zero)"), frameno);
2431 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2436 trace_find_end_command (char *args, int from_tty)
2438 trace_find_command ("-1", from_tty);
2443 trace_find_start_command (char *args, int from_tty)
2445 trace_find_command ("0", from_tty);
2448 /* tfind pc command */
2450 trace_find_pc_command (char *args, int from_tty)
2454 if (current_trace_status ()->running
2455 && current_trace_status ()->filename == NULL)
2456 error (_("May not look at trace frames while trace is running."));
2458 if (args == 0 || *args == 0)
2459 pc = regcache_read_pc (get_current_regcache ());
2461 pc = parse_and_eval_address (args);
2463 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2466 /* tfind tracepoint command */
2468 trace_find_tracepoint_command (char *args, int from_tty)
2471 struct tracepoint *tp;
2473 if (current_trace_status ()->running
2474 && current_trace_status ()->filename == NULL)
2475 error (_("May not look at trace frames while trace is running."));
2477 if (args == 0 || *args == 0)
2479 if (tracepoint_number == -1)
2480 error (_("No current tracepoint -- please supply an argument."));
2482 tdp = tracepoint_number; /* Default is current TDP. */
2485 tdp = parse_and_eval_long (args);
2487 /* If we have the tracepoint on hand, use the number that the
2488 target knows about (which may be different if we disconnected
2489 and reconnected). */
2490 tp = get_tracepoint (tdp);
2492 tdp = tp->number_on_target;
2494 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2497 /* TFIND LINE command:
2499 This command will take a sourceline for argument, just like BREAK
2500 or TRACE (ie. anything that "decode_line_1" can handle).
2502 With no argument, this command will find the next trace frame
2503 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2506 trace_find_line_command (char *args, int from_tty)
2508 static CORE_ADDR start_pc, end_pc;
2509 struct symtabs_and_lines sals;
2510 struct symtab_and_line sal;
2511 struct cleanup *old_chain;
2513 if (current_trace_status ()->running
2514 && current_trace_status ()->filename == NULL)
2515 error (_("May not look at trace frames while trace is running."));
2517 if (args == 0 || *args == 0)
2519 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2521 sals.sals = (struct symtab_and_line *)
2522 xmalloc (sizeof (struct symtab_and_line));
2527 sals = decode_line_with_current_source (args, DECODE_LINE_FUNFIRSTLINE);
2531 old_chain = make_cleanup (xfree, sals.sals);
2532 if (sal.symtab == 0)
2533 error (_("No line number information available."));
2535 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2537 if (start_pc == end_pc)
2539 printf_filtered ("Line %d of \"%s\"",
2541 symtab_to_filename_for_display (sal.symtab));
2543 printf_filtered (" is at address ");
2544 print_address (get_current_arch (), start_pc, gdb_stdout);
2546 printf_filtered (" but contains no code.\n");
2547 sal = find_pc_line (start_pc, 0);
2549 && find_line_pc_range (sal, &start_pc, &end_pc)
2550 && start_pc != end_pc)
2551 printf_filtered ("Attempting to find line %d instead.\n",
2554 error (_("Cannot find a good line."));
2558 /* Is there any case in which we get here, and have an address
2559 which the user would want to see? If we have debugging
2560 symbols and no line numbers? */
2561 error (_("Line number %d is out of range for \"%s\"."),
2562 sal.line, symtab_to_filename_for_display (sal.symtab));
2564 /* Find within range of stated line. */
2566 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2568 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2569 do_cleanups (old_chain);
2572 /* tfind range command */
2574 trace_find_range_command (char *args, int from_tty)
2576 static CORE_ADDR start, stop;
2579 if (current_trace_status ()->running
2580 && current_trace_status ()->filename == NULL)
2581 error (_("May not look at trace frames while trace is running."));
2583 if (args == 0 || *args == 0)
2584 { /* XXX FIXME: what should default behavior be? */
2585 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2589 if (0 != (tmp = strchr (args, ',')))
2591 *tmp++ = '\0'; /* Terminate start address. */
2592 while (isspace ((int) *tmp))
2594 start = parse_and_eval_address (args);
2595 stop = parse_and_eval_address (tmp);
2598 { /* No explicit end address? */
2599 start = parse_and_eval_address (args);
2600 stop = start + 1; /* ??? */
2603 tfind_1 (tfind_range, 0, start, stop, from_tty);
2606 /* tfind outside command */
2608 trace_find_outside_command (char *args, int from_tty)
2610 CORE_ADDR start, stop;
2613 if (current_trace_status ()->running
2614 && current_trace_status ()->filename == NULL)
2615 error (_("May not look at trace frames while trace is running."));
2617 if (args == 0 || *args == 0)
2618 { /* XXX FIXME: what should default behavior be? */
2619 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2623 if (0 != (tmp = strchr (args, ',')))
2625 *tmp++ = '\0'; /* Terminate start address. */
2626 while (isspace ((int) *tmp))
2628 start = parse_and_eval_address (args);
2629 stop = parse_and_eval_address (tmp);
2632 { /* No explicit end address? */
2633 start = parse_and_eval_address (args);
2634 stop = start + 1; /* ??? */
2637 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2640 /* info scope command: list the locals for a scope. */
2642 scope_info (char *args, int from_tty)
2644 struct symtabs_and_lines sals;
2646 struct minimal_symbol *msym;
2647 struct block *block;
2648 const char *symname;
2649 char *save_args = args;
2650 struct block_iterator iter;
2652 struct gdbarch *gdbarch;
2655 if (args == 0 || *args == 0)
2656 error (_("requires an argument (function, "
2657 "line or *addr) to define a scope"));
2659 sals = decode_line_1 (&args, DECODE_LINE_FUNFIRSTLINE, NULL, 0);
2660 if (sals.nelts == 0)
2661 return; /* Presumably decode_line_1 has already warned. */
2663 /* Resolve line numbers to PC. */
2664 resolve_sal_pc (&sals.sals[0]);
2665 block = block_for_pc (sals.sals[0].pc);
2669 QUIT; /* Allow user to bail out with ^C. */
2670 ALL_BLOCK_SYMBOLS (block, iter, sym)
2672 QUIT; /* Allow user to bail out with ^C. */
2674 printf_filtered ("Scope for %s:\n", save_args);
2677 symname = SYMBOL_PRINT_NAME (sym);
2678 if (symname == NULL || *symname == '\0')
2679 continue; /* Probably botched, certainly useless. */
2681 gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
2683 printf_filtered ("Symbol %s is ", symname);
2684 switch (SYMBOL_CLASS (sym))
2687 case LOC_UNDEF: /* Messed up symbol? */
2688 printf_filtered ("a bogus symbol, class %d.\n",
2689 SYMBOL_CLASS (sym));
2690 count--; /* Don't count this one. */
2693 printf_filtered ("a constant with value %s (%s)",
2694 plongest (SYMBOL_VALUE (sym)),
2695 hex_string (SYMBOL_VALUE (sym)));
2697 case LOC_CONST_BYTES:
2698 printf_filtered ("constant bytes: ");
2699 if (SYMBOL_TYPE (sym))
2700 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2701 fprintf_filtered (gdb_stdout, " %02x",
2702 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2705 printf_filtered ("in static storage at address ");
2706 printf_filtered ("%s", paddress (gdbarch,
2707 SYMBOL_VALUE_ADDRESS (sym)));
2710 /* GDBARCH is the architecture associated with the objfile
2711 the symbol is defined in; the target architecture may be
2712 different, and may provide additional registers. However,
2713 we do not know the target architecture at this point.
2714 We assume the objfile architecture will contain all the
2715 standard registers that occur in debug info in that
2717 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2720 if (SYMBOL_IS_ARGUMENT (sym))
2721 printf_filtered ("an argument in register $%s",
2722 gdbarch_register_name (gdbarch, regno));
2724 printf_filtered ("a local variable in register $%s",
2725 gdbarch_register_name (gdbarch, regno));
2728 printf_filtered ("an argument at stack/frame offset %s",
2729 plongest (SYMBOL_VALUE (sym)));
2732 printf_filtered ("a local variable at frame offset %s",
2733 plongest (SYMBOL_VALUE (sym)));
2736 printf_filtered ("a reference argument at offset %s",
2737 plongest (SYMBOL_VALUE (sym)));
2739 case LOC_REGPARM_ADDR:
2740 /* Note comment at LOC_REGISTER. */
2741 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2743 printf_filtered ("the address of an argument, in register $%s",
2744 gdbarch_register_name (gdbarch, regno));
2747 printf_filtered ("a typedef.\n");
2750 printf_filtered ("a label at address ");
2751 printf_filtered ("%s", paddress (gdbarch,
2752 SYMBOL_VALUE_ADDRESS (sym)));
2755 printf_filtered ("a function at address ");
2756 printf_filtered ("%s",
2757 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2759 case LOC_UNRESOLVED:
2760 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2763 printf_filtered ("Unresolved Static");
2766 printf_filtered ("static storage at address ");
2767 printf_filtered ("%s",
2768 paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msym)));
2771 case LOC_OPTIMIZED_OUT:
2772 printf_filtered ("optimized out.\n");
2775 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2776 BLOCK_START (block),
2780 if (SYMBOL_TYPE (sym))
2781 printf_filtered (", length %d.\n",
2782 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2784 if (BLOCK_FUNCTION (block))
2787 block = BLOCK_SUPERBLOCK (block);
2790 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2794 /* worker function (cleanup) */
2796 replace_comma (void *data)
2803 /* Helper for trace_dump_command. Dump the action list starting at
2804 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2805 actions of the body of a while-stepping action. STEPPING_FRAME is
2806 set if the current traceframe was determined to be a while-stepping
2810 trace_dump_actions (struct command_line *action,
2811 int stepping_actions, int stepping_frame,
2814 char *action_exp, *next_comma;
2816 for (; action != NULL; action = action->next)
2818 struct cmd_list_element *cmd;
2820 QUIT; /* Allow user to bail out with ^C. */
2821 action_exp = action->line;
2822 while (isspace ((int) *action_exp))
2825 /* The collection actions to be done while stepping are
2826 bracketed by the commands "while-stepping" and "end". */
2828 if (*action_exp == '#') /* comment line */
2831 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2833 error (_("Bad action list item: %s"), action_exp);
2835 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2839 for (i = 0; i < action->body_count; ++i)
2840 trace_dump_actions (action->body_list[i],
2841 1, stepping_frame, from_tty);
2843 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2845 /* Display the collected data.
2846 For the trap frame, display only what was collected at
2847 the trap. Likewise for stepping frames, display only
2848 what was collected while stepping. This means that the
2849 two boolean variables, STEPPING_FRAME and
2850 STEPPING_ACTIONS should be equal. */
2851 if (stepping_frame == stepping_actions)
2853 if (*action_exp == '/')
2854 action_exp = decode_agent_options (action_exp);
2857 { /* Repeat over a comma-separated list. */
2858 QUIT; /* Allow user to bail out with ^C. */
2859 if (*action_exp == ',')
2861 while (isspace ((int) *action_exp))
2864 next_comma = strchr (action_exp, ',');
2866 if (0 == strncasecmp (action_exp, "$reg", 4))
2867 registers_info (NULL, from_tty);
2868 else if (0 == strncasecmp (action_exp, "$_ret", 5))
2870 else if (0 == strncasecmp (action_exp, "$loc", 4))
2871 locals_info (NULL, from_tty);
2872 else if (0 == strncasecmp (action_exp, "$arg", 4))
2873 args_info (NULL, from_tty);
2878 make_cleanup (replace_comma, next_comma);
2881 printf_filtered ("%s = ", action_exp);
2882 output_command (action_exp, from_tty);
2883 printf_filtered ("\n");
2887 action_exp = next_comma;
2889 while (action_exp && *action_exp == ',');
2895 /* The tdump command. */
2898 trace_dump_command (char *args, int from_tty)
2900 struct regcache *regcache;
2901 struct tracepoint *t;
2902 int stepping_frame = 0;
2903 struct bp_location *loc;
2904 char *line, *default_collect_line = NULL;
2905 struct command_line *actions, *default_collect_action = NULL;
2906 struct cleanup *old_chain = NULL;
2908 if (tracepoint_number == -1)
2910 warning (_("No current trace frame."));
2914 t = get_tracepoint (tracepoint_number);
2917 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2920 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2921 tracepoint_number, traceframe_number);
2923 /* The current frame is a trap frame if the frame PC is equal
2924 to the tracepoint PC. If not, then the current frame was
2925 collected during single-stepping. */
2927 regcache = get_current_regcache ();
2929 /* If the traceframe's address matches any of the tracepoint's
2930 locations, assume it is a direct hit rather than a while-stepping
2931 frame. (FIXME this is not reliable, should record each frame's
2934 for (loc = t->base.loc; loc; loc = loc->next)
2935 if (loc->address == regcache_read_pc (regcache))
2938 actions = breakpoint_commands (&t->base);
2940 /* If there is a default-collect list, make up a collect command,
2941 prepend to the tracepoint's commands, and pass the whole mess to
2942 the trace dump scanner. We need to validate because
2943 default-collect might have been junked since the trace run. */
2944 if (*default_collect)
2946 default_collect_line = xstrprintf ("collect %s", default_collect);
2947 old_chain = make_cleanup (xfree, default_collect_line);
2948 line = default_collect_line;
2949 validate_actionline (&line, &t->base);
2950 default_collect_action = xmalloc (sizeof (struct command_line));
2951 make_cleanup (xfree, default_collect_action);
2952 default_collect_action->next = actions;
2953 default_collect_action->line = line;
2954 actions = default_collect_action;
2957 trace_dump_actions (actions, 0, stepping_frame, from_tty);
2959 if (*default_collect)
2960 do_cleanups (old_chain);
2963 /* Encode a piece of a tracepoint's source-level definition in a form
2964 that is suitable for both protocol and saving in files. */
2965 /* This version does not do multiple encodes for long strings; it should
2966 return an offset to the next piece to encode. FIXME */
2969 encode_source_string (int tpnum, ULONGEST addr,
2970 char *srctype, char *src, char *buf, int buf_size)
2972 if (80 + strlen (srctype) > buf_size)
2973 error (_("Buffer too small for source encoding"));
2974 sprintf (buf, "%x:%s:%s:%x:%x:",
2975 tpnum, phex_nz (addr, sizeof (addr)),
2976 srctype, 0, (int) strlen (src));
2977 if (strlen (buf) + strlen (src) * 2 >= buf_size)
2978 error (_("Source string too long for buffer"));
2979 bin2hex (src, buf + strlen (buf), 0);
2983 extern int trace_regblock_size;
2985 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2986 non-zero, the save is performed on the target, otherwise GDB obtains all
2987 trace data and saves it locally. */
2990 trace_save (const char *filename, int target_does_save)
2992 struct cleanup *cleanup;
2994 struct trace_status *ts = current_trace_status ();
2997 struct uploaded_tp *uploaded_tps = NULL, *utp;
2998 struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
3002 ULONGEST offset = 0;
3003 #define MAX_TRACE_UPLOAD 2000
3004 gdb_byte buf[MAX_TRACE_UPLOAD];
3007 /* If the target is to save the data to a file on its own, then just
3008 send the command and be done with it. */
3009 if (target_does_save)
3011 err = target_save_trace_data (filename);
3013 error (_("Target failed to save trace data to '%s'."),
3018 /* Get the trace status first before opening the file, so if the
3019 target is losing, we can get out without touching files. */
3020 status = target_get_trace_status (ts);
3022 pathname = tilde_expand (filename);
3023 cleanup = make_cleanup (xfree, pathname);
3025 fp = fopen (pathname, "wb");
3027 error (_("Unable to open file '%s' for saving trace data (%s)"),
3028 filename, safe_strerror (errno));
3029 make_cleanup_fclose (fp);
3031 /* Write a file header, with a high-bit-set char to indicate a
3032 binary file, plus a hint as what this file is, and a version
3033 number in case of future needs. */
3034 written = fwrite ("\x7fTRACE0\n", 8, 1, fp);
3036 perror_with_name (pathname);
3038 /* Write descriptive info. */
3040 /* Write out the size of a register block. */
3041 fprintf (fp, "R %x\n", trace_regblock_size);
3043 /* Write out status of the tracing run (aka "tstatus" info). */
3044 fprintf (fp, "status %c;%s",
3045 (ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
3046 if (ts->stop_reason == tracepoint_error)
3048 char *buf = (char *) alloca (strlen (ts->stop_desc) * 2 + 1);
3050 bin2hex ((gdb_byte *) ts->stop_desc, buf, 0);
3051 fprintf (fp, ":%s", buf);
3053 fprintf (fp, ":%x", ts->stopping_tracepoint);
3054 if (ts->traceframe_count >= 0)
3055 fprintf (fp, ";tframes:%x", ts->traceframe_count);
3056 if (ts->traceframes_created >= 0)
3057 fprintf (fp, ";tcreated:%x", ts->traceframes_created);
3058 if (ts->buffer_free >= 0)
3059 fprintf (fp, ";tfree:%x", ts->buffer_free);
3060 if (ts->buffer_size >= 0)
3061 fprintf (fp, ";tsize:%x", ts->buffer_size);
3062 if (ts->disconnected_tracing)
3063 fprintf (fp, ";disconn:%x", ts->disconnected_tracing);
3064 if (ts->circular_buffer)
3065 fprintf (fp, ";circular:%x", ts->circular_buffer);
3068 /* Note that we want to upload tracepoints and save those, rather
3069 than simply writing out the local ones, because the user may have
3070 changed tracepoints in GDB in preparation for a future tracing
3071 run, or maybe just mass-deleted all types of breakpoints as part
3072 of cleaning up. So as not to contaminate the session, leave the
3073 data in its uploaded form, don't make into real tracepoints. */
3075 /* Get trace state variables first, they may be checked when parsing
3076 uploaded commands. */
3078 target_upload_trace_state_variables (&uploaded_tsvs);
3080 for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
3086 buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
3087 bin2hex ((gdb_byte *) (utsv->name), buf, 0);
3090 fprintf (fp, "tsv %x:%s:%x:%s\n",
3091 utsv->number, phex_nz (utsv->initial_value, 8),
3092 utsv->builtin, buf);
3098 free_uploaded_tsvs (&uploaded_tsvs);
3100 target_upload_tracepoints (&uploaded_tps);
3102 for (utp = uploaded_tps; utp; utp = utp->next)
3103 target_get_tracepoint_status (NULL, utp);
3105 for (utp = uploaded_tps; utp; utp = utp->next)
3107 fprintf (fp, "tp T%x:%s:%c:%x:%x",
3108 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
3109 (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
3110 if (utp->type == bp_fast_tracepoint)
3111 fprintf (fp, ":F%x", utp->orig_size);
3113 fprintf (fp, ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
3116 for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
3117 fprintf (fp, "tp A%x:%s:%s\n",
3118 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
3119 for (a = 0; VEC_iterate (char_ptr, utp->step_actions, a, act); ++a)
3120 fprintf (fp, "tp S%x:%s:%s\n",
3121 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
3124 encode_source_string (utp->number, utp->addr,
3125 "at", utp->at_string, buf, MAX_TRACE_UPLOAD);
3126 fprintf (fp, "tp Z%s\n", buf);
3128 if (utp->cond_string)
3130 encode_source_string (utp->number, utp->addr,
3131 "cond", utp->cond_string,
3132 buf, MAX_TRACE_UPLOAD);
3133 fprintf (fp, "tp Z%s\n", buf);
3135 for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
3137 encode_source_string (utp->number, utp->addr, "cmd", act,
3138 buf, MAX_TRACE_UPLOAD);
3139 fprintf (fp, "tp Z%s\n", buf);
3141 fprintf (fp, "tp V%x:%s:%x:%s\n",
3142 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
3144 phex_nz (utp->traceframe_usage,
3145 sizeof (utp->traceframe_usage)));
3148 free_uploaded_tps (&uploaded_tps);
3150 /* Mark the end of the definition section. */
3153 /* Get and write the trace data proper. We ask for big blocks, in
3154 the hopes of efficiency, but will take less if the target has
3155 packet size limitations or some such. */
3158 gotten = target_get_raw_trace_data (buf, offset, MAX_TRACE_UPLOAD);
3160 error (_("Failure to get requested trace buffer data"));
3161 /* No more data is forthcoming, we're done. */
3164 written = fwrite (buf, gotten, 1, fp);
3166 perror_with_name (pathname);
3170 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
3171 written = fwrite (&gotten, 4, 1, fp);
3173 perror_with_name (pathname);
3175 do_cleanups (cleanup);
3179 trace_save_command (char *args, int from_tty)
3181 int target_does_save = 0;
3183 char *filename = NULL;
3184 struct cleanup *back_to;
3187 error_no_arg (_("file in which to save trace data"));
3189 argv = gdb_buildargv (args);
3190 back_to = make_cleanup_freeargv (argv);
3192 for (; *argv; ++argv)
3194 if (strcmp (*argv, "-r") == 0)
3195 target_does_save = 1;
3196 else if (**argv == '-')
3197 error (_("unknown option `%s'"), *argv);
3203 error_no_arg (_("file in which to save trace data"));
3205 trace_save (filename, target_does_save);
3208 printf_filtered (_("Trace data saved to file '%s'.\n"), filename);
3210 do_cleanups (back_to);
3213 /* Tell the target what to do with an ongoing tracing run if GDB
3214 disconnects for some reason. */
3217 set_disconnected_tracing (char *args, int from_tty,
3218 struct cmd_list_element *c)
3220 target_set_disconnected_tracing (disconnected_tracing);
3224 set_circular_trace_buffer (char *args, int from_tty,
3225 struct cmd_list_element *c)
3227 target_set_circular_trace_buffer (circular_trace_buffer);
3231 set_trace_user (char *args, int from_tty,
3232 struct cmd_list_element *c)
3236 ret = target_set_trace_notes (trace_user, NULL, NULL);
3239 warning (_("Target does not support trace notes, user ignored"));
3243 set_trace_notes (char *args, int from_tty,
3244 struct cmd_list_element *c)
3248 ret = target_set_trace_notes (NULL, trace_notes, NULL);
3251 warning (_("Target does not support trace notes, note ignored"));
3255 set_trace_stop_notes (char *args, int from_tty,
3256 struct cmd_list_element *c)
3260 ret = target_set_trace_notes (NULL, NULL, trace_stop_notes);
3263 warning (_("Target does not support trace notes, stop note ignored"));
3266 /* Convert the memory pointed to by mem into hex, placing result in buf.
3267 * Return a pointer to the last char put in buf (null)
3268 * "stolen" from sparc-stub.c
3271 static const char hexchars[] = "0123456789abcdef";
3274 mem2hex (gdb_byte *mem, char *buf, int count)
3282 *buf++ = hexchars[ch >> 4];
3283 *buf++ = hexchars[ch & 0xf];
3292 get_traceframe_number (void)
3294 return traceframe_number;
3297 /* Make the traceframe NUM be the current trace frame. Does nothing
3298 if NUM is already current. */
3301 set_current_traceframe (int num)
3305 if (traceframe_number == num)
3307 /* Nothing to do. */
3311 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
3314 warning (_("could not change traceframe"));
3316 set_traceframe_num (newnum);
3318 /* Changing the traceframe changes our view of registers and of the
3320 registers_changed ();
3322 clear_traceframe_info ();
3325 /* Make the traceframe NUM be the current trace frame, and do nothing
3329 set_traceframe_number (int num)
3331 traceframe_number = num;
3334 /* A cleanup used when switching away and back from tfind mode. */
3336 struct current_traceframe_cleanup
3338 /* The traceframe we were inspecting. */
3339 int traceframe_number;
3343 do_restore_current_traceframe_cleanup (void *arg)
3345 struct current_traceframe_cleanup *old = arg;
3347 set_current_traceframe (old->traceframe_number);
3351 restore_current_traceframe_cleanup_dtor (void *arg)
3353 struct current_traceframe_cleanup *old = arg;
3359 make_cleanup_restore_current_traceframe (void)
3361 struct current_traceframe_cleanup *old;
3363 old = xmalloc (sizeof (struct current_traceframe_cleanup));
3364 old->traceframe_number = traceframe_number;
3366 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
3367 restore_current_traceframe_cleanup_dtor);
3371 make_cleanup_restore_traceframe_number (void)
3373 return make_cleanup_restore_integer (&traceframe_number);
3376 /* Given a number and address, return an uploaded tracepoint with that
3377 number, creating if necessary. */
3379 struct uploaded_tp *
3380 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
3382 struct uploaded_tp *utp;
3384 for (utp = *utpp; utp; utp = utp->next)
3385 if (utp->number == num && utp->addr == addr)
3387 utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
3388 memset (utp, 0, sizeof (struct uploaded_tp));
3391 utp->actions = NULL;
3392 utp->step_actions = NULL;
3393 utp->cmd_strings = NULL;
3400 free_uploaded_tps (struct uploaded_tp **utpp)
3402 struct uploaded_tp *next_one;
3406 next_one = (*utpp)->next;
3412 /* Given a number and address, return an uploaded tracepoint with that
3413 number, creating if necessary. */
3415 static struct uploaded_tsv *
3416 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
3418 struct uploaded_tsv *utsv;
3420 for (utsv = *utsvp; utsv; utsv = utsv->next)
3421 if (utsv->number == num)
3423 utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
3424 memset (utsv, 0, sizeof (struct uploaded_tsv));
3426 utsv->next = *utsvp;
3432 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3434 struct uploaded_tsv *next_one;
3438 next_one = (*utsvp)->next;
3444 /* FIXME this function is heuristic and will miss the cases where the
3445 conditional is semantically identical but differs in whitespace,
3446 such as "x == 0" vs "x==0". */
3449 cond_string_is_same (char *str1, char *str2)
3451 if (str1 == NULL || str2 == NULL)
3452 return (str1 == str2);
3454 return (strcmp (str1, str2) == 0);
3457 /* Look for an existing tracepoint that seems similar enough to the
3458 uploaded one. Enablement isn't compared, because the user can
3459 toggle that freely, and may have done so in anticipation of the
3460 next trace run. Return the location of matched tracepoint. */
3462 static struct bp_location *
3463 find_matching_tracepoint_location (struct uploaded_tp *utp)
3465 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
3467 struct breakpoint *b;
3468 struct bp_location *loc;
3470 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
3472 struct tracepoint *t = (struct tracepoint *) b;
3474 if (b->type == utp->type
3475 && t->step_count == utp->step
3476 && t->pass_count == utp->pass
3477 && cond_string_is_same (t->base.cond_string, utp->cond_string)
3478 /* FIXME also test actions. */
3481 /* Scan the locations for an address match. */
3482 for (loc = b->loc; loc; loc = loc->next)
3484 if (loc->address == utp->addr)
3492 /* Given a list of tracepoints uploaded from a target, attempt to
3493 match them up with existing tracepoints, and create new ones if not
3497 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3499 struct uploaded_tp *utp;
3500 /* A set of tracepoints which are modified. */
3501 VEC(breakpoint_p) *modified_tp = NULL;
3503 struct breakpoint *b;
3505 /* Look for GDB tracepoints that match up with our uploaded versions. */
3506 for (utp = *uploaded_tps; utp; utp = utp->next)
3508 struct bp_location *loc;
3509 struct tracepoint *t;
3511 loc = find_matching_tracepoint_location (utp);
3516 /* Mark this location as already inserted. */
3518 t = (struct tracepoint *) loc->owner;
3519 printf_filtered (_("Assuming tracepoint %d is same "
3520 "as target's tracepoint %d at %s.\n"),
3521 loc->owner->number, utp->number,
3522 paddress (loc->gdbarch, utp->addr));
3524 /* The tracepoint LOC->owner was modified (the location LOC
3525 was marked as inserted in the target). Save it in
3526 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3527 observers will be notified later once for each tracepoint
3528 saved in MODIFIED_TP. */
3530 VEC_iterate (breakpoint_p, modified_tp, ix, b);
3532 if (b == loc->owner)
3538 VEC_safe_push (breakpoint_p, modified_tp, loc->owner);
3542 t = create_tracepoint_from_upload (utp);
3544 printf_filtered (_("Created tracepoint %d for "
3545 "target's tracepoint %d at %s.\n"),
3546 t->base.number, utp->number,
3547 paddress (get_current_arch (), utp->addr));
3549 printf_filtered (_("Failed to create tracepoint for target's "
3550 "tracepoint %d at %s, skipping it.\n"),
3552 paddress (get_current_arch (), utp->addr));
3554 /* Whether found or created, record the number used by the
3555 target, to help with mapping target tracepoints back to their
3556 counterparts here. */
3558 t->number_on_target = utp->number;
3561 /* Notify 'breakpoint-modified' observer that at least one of B's
3562 locations was changed. */
3563 for (ix = 0; VEC_iterate (breakpoint_p, modified_tp, ix, b); ix++)
3564 observer_notify_breakpoint_modified (b);
3566 VEC_free (breakpoint_p, modified_tp);
3567 free_uploaded_tps (uploaded_tps);
3570 /* Trace state variables don't have much to identify them beyond their
3571 name, so just use that to detect matches. */
3573 static struct trace_state_variable *
3574 find_matching_tsv (struct uploaded_tsv *utsv)
3579 return find_trace_state_variable (utsv->name);
3582 static struct trace_state_variable *
3583 create_tsv_from_upload (struct uploaded_tsv *utsv)
3585 const char *namebase;
3588 struct trace_state_variable *tsv;
3589 struct cleanup *old_chain;
3593 namebase = utsv->name;
3594 buf = xstrprintf ("%s", namebase);
3599 buf = xstrprintf ("%s_%d", namebase, try_num++);
3602 /* Fish for a name that is not in use. */
3603 /* (should check against all internal vars?) */
3604 while (find_trace_state_variable (buf))
3607 buf = xstrprintf ("%s_%d", namebase, try_num++);
3610 old_chain = make_cleanup (xfree, buf);
3612 /* We have an available name, create the variable. */
3613 tsv = create_trace_state_variable (buf);
3614 tsv->initial_value = utsv->initial_value;
3615 tsv->builtin = utsv->builtin;
3617 observer_notify_tsv_created (tsv);
3619 do_cleanups (old_chain);
3624 /* Given a list of uploaded trace state variables, try to match them
3625 up with existing variables, or create additional ones. */
3628 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
3631 struct uploaded_tsv *utsv;
3632 struct trace_state_variable *tsv;
3635 /* Most likely some numbers will have to be reassigned as part of
3636 the merge, so clear them all in anticipation. */
3637 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3640 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
3642 tsv = find_matching_tsv (utsv);
3646 printf_filtered (_("Assuming trace state variable $%s "
3647 "is same as target's variable %d.\n"),
3648 tsv->name, utsv->number);
3652 tsv = create_tsv_from_upload (utsv);
3654 printf_filtered (_("Created trace state variable "
3655 "$%s for target's variable %d.\n"),
3656 tsv->name, utsv->number);
3658 /* Give precedence to numberings that come from the target. */
3660 tsv->number = utsv->number;
3663 /* Renumber everything that didn't get a target-assigned number. */
3665 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3666 if (tsv->number > highest)
3667 highest = tsv->number;
3670 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3671 if (tsv->number == 0)
3672 tsv->number = highest++;
3674 free_uploaded_tsvs (uploaded_tsvs);
3677 /* target tfile command */
3679 static struct target_ops tfile_ops;
3681 /* Fill in tfile_ops with its defined operations and properties. */
3683 #define TRACE_HEADER_SIZE 8
3685 static char *trace_filename;
3686 static int trace_fd = -1;
3687 static off_t trace_frames_offset;
3688 static off_t cur_offset;
3689 static int cur_data_size;
3690 int trace_regblock_size;
3692 static void tfile_interp_line (char *line,
3693 struct uploaded_tp **utpp,
3694 struct uploaded_tsv **utsvp);
3696 /* Read SIZE bytes into READBUF from the trace frame, starting at
3697 TRACE_FD's current position. Note that this call `read'
3698 underneath, hence it advances the file's seek position. Throws an
3699 error if the `read' syscall fails, or less than SIZE bytes are
3703 tfile_read (gdb_byte *readbuf, int size)
3707 gotten = read (trace_fd, readbuf, size);
3709 perror_with_name (trace_filename);
3710 else if (gotten < size)
3711 error (_("Premature end of file while reading trace file"));
3715 tfile_open (char *filename, int from_tty)
3717 volatile struct gdb_exception ex;
3719 struct cleanup *old_chain;
3722 char header[TRACE_HEADER_SIZE];
3723 char linebuf[1000]; /* Should be max remote packet size or so. */
3726 struct trace_status *ts;
3727 struct uploaded_tp *uploaded_tps = NULL;
3728 struct uploaded_tsv *uploaded_tsvs = NULL;
3730 target_preopen (from_tty);
3732 error (_("No trace file specified."));
3734 filename = tilde_expand (filename);
3735 if (!IS_ABSOLUTE_PATH(filename))
3737 temp = concat (current_directory, "/", filename, (char *) NULL);
3742 old_chain = make_cleanup (xfree, filename);
3744 flags = O_BINARY | O_LARGEFILE;
3746 scratch_chan = open (filename, flags, 0);
3747 if (scratch_chan < 0)
3748 perror_with_name (filename);
3750 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3752 discard_cleanups (old_chain); /* Don't free filename any more. */
3753 unpush_target (&tfile_ops);
3755 trace_filename = xstrdup (filename);
3756 trace_fd = scratch_chan;
3759 /* Read the file header and test for validity. */
3760 tfile_read ((gdb_byte *) &header, TRACE_HEADER_SIZE);
3762 bytes += TRACE_HEADER_SIZE;
3763 if (!(header[0] == 0x7f
3764 && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
3765 error (_("File is not a valid trace file."));
3767 push_target (&tfile_ops);
3769 trace_regblock_size = 0;
3770 ts = current_trace_status ();
3771 /* We know we're working with a file. Record its name. */
3772 ts->filename = trace_filename;
3773 /* Set defaults in case there is no status line. */
3774 ts->running_known = 0;
3775 ts->stop_reason = trace_stop_reason_unknown;
3776 ts->traceframe_count = -1;
3777 ts->buffer_free = 0;
3778 ts->disconnected_tracing = 0;
3779 ts->circular_buffer = 0;
3781 TRY_CATCH (ex, RETURN_MASK_ALL)
3783 /* Read through a section of newline-terminated lines that
3784 define things like tracepoints. */
3788 tfile_read (&byte, 1);
3793 /* Empty line marks end of the definition section. */
3798 tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
3801 linebuf[i++] = byte;
3803 error (_("Excessively long lines in trace file"));
3806 /* Record the starting offset of the binary trace data. */
3807 trace_frames_offset = bytes;
3809 /* If we don't have a blocksize, we can't interpret the
3811 if (trace_regblock_size == 0)
3812 error (_("No register block size recorded in trace file"));
3816 /* Pop the partially set up target. */
3818 throw_exception (ex);
3821 inferior_appeared (current_inferior (), TFILE_PID);
3822 inferior_ptid = pid_to_ptid (TFILE_PID);
3823 add_thread_silent (inferior_ptid);
3825 if (ts->traceframe_count <= 0)
3826 warning (_("No traceframes present in this file."));
3828 /* Add the file's tracepoints and variables into the current mix. */
3830 /* Get trace state variables first, they may be checked when parsing
3831 uploaded commands. */
3832 merge_uploaded_trace_state_variables (&uploaded_tsvs);
3834 merge_uploaded_tracepoints (&uploaded_tps);
3836 post_create_inferior (&tfile_ops, from_tty);
3839 /* Interpret the given line from the definitions part of the trace
3843 tfile_interp_line (char *line,
3844 struct uploaded_tp **utpp, struct uploaded_tsv **utsvp)
3848 if (strncmp (p, "R ", strlen ("R ")) == 0)
3851 trace_regblock_size = strtol (p, &p, 16);
3853 else if (strncmp (p, "status ", strlen ("status ")) == 0)
3855 p += strlen ("status ");
3856 parse_trace_status (p, current_trace_status ());
3858 else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
3860 p += strlen ("tp ");
3861 parse_tracepoint_definition (p, utpp);
3863 else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
3865 p += strlen ("tsv ");
3866 parse_tsv_definition (p, utsvp);
3869 warning (_("Ignoring trace file definition \"%s\""), line);
3872 /* Parse the part of trace status syntax that is shared between
3873 the remote protocol and the trace file reader. */
3876 parse_trace_status (char *line, struct trace_status *ts)
3878 char *p = line, *p1, *p2, *p3, *p_temp;
3882 ts->running_known = 1;
3883 ts->running = (*p++ == '1');
3884 ts->stop_reason = trace_stop_reason_unknown;
3885 xfree (ts->stop_desc);
3886 ts->stop_desc = NULL;
3887 ts->traceframe_count = -1;
3888 ts->traceframes_created = -1;
3889 ts->buffer_free = -1;
3890 ts->buffer_size = -1;
3891 ts->disconnected_tracing = 0;
3892 ts->circular_buffer = 0;
3893 xfree (ts->user_name);
3894 ts->user_name = NULL;
3897 ts->start_time = ts->stop_time = 0;
3901 p1 = strchr (p, ':');
3903 error (_("Malformed trace status, at %s\n\
3904 Status line: '%s'\n"), p, line);
3905 p3 = strchr (p, ';');
3907 p3 = p + strlen (p);
3908 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3910 p = unpack_varlen_hex (++p1, &val);
3911 ts->stop_reason = trace_buffer_full;
3913 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3915 p = unpack_varlen_hex (++p1, &val);
3916 ts->stop_reason = trace_never_run;
3918 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
3921 p = unpack_varlen_hex (++p1, &val);
3922 ts->stop_reason = tracepoint_passcount;
3923 ts->stopping_tracepoint = val;
3925 else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
3927 p2 = strchr (++p1, ':');
3935 ts->stop_desc = xmalloc (strlen (line));
3936 end = hex2bin (p1, ts->stop_desc, (p2 - p1) / 2);
3937 ts->stop_desc[end] = '\0';
3940 ts->stop_desc = xstrdup ("");
3942 p = unpack_varlen_hex (++p2, &val);
3943 ts->stop_reason = tstop_command;
3945 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
3947 p = unpack_varlen_hex (++p1, &val);
3948 ts->stop_reason = trace_disconnected;
3950 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
3952 p2 = strchr (++p1, ':');
3955 ts->stop_desc = xmalloc ((p2 - p1) / 2 + 1);
3956 end = hex2bin (p1, ts->stop_desc, (p2 - p1) / 2);
3957 ts->stop_desc[end] = '\0';
3960 ts->stop_desc = xstrdup ("");
3962 p = unpack_varlen_hex (++p2, &val);
3963 ts->stopping_tracepoint = val;
3964 ts->stop_reason = tracepoint_error;
3966 else if (strncmp (p, "tframes", p1 - p) == 0)
3968 p = unpack_varlen_hex (++p1, &val);
3969 ts->traceframe_count = val;
3971 else if (strncmp (p, "tcreated", p1 - p) == 0)
3973 p = unpack_varlen_hex (++p1, &val);
3974 ts->traceframes_created = val;
3976 else if (strncmp (p, "tfree", p1 - p) == 0)
3978 p = unpack_varlen_hex (++p1, &val);
3979 ts->buffer_free = val;
3981 else if (strncmp (p, "tsize", p1 - p) == 0)
3983 p = unpack_varlen_hex (++p1, &val);
3984 ts->buffer_size = val;
3986 else if (strncmp (p, "disconn", p1 - p) == 0)
3988 p = unpack_varlen_hex (++p1, &val);
3989 ts->disconnected_tracing = val;
3991 else if (strncmp (p, "circular", p1 - p) == 0)
3993 p = unpack_varlen_hex (++p1, &val);
3994 ts->circular_buffer = val;
3996 else if (strncmp (p, "starttime", p1 - p) == 0)
3998 p = unpack_varlen_hex (++p1, &val);
3999 ts->start_time = val;
4001 else if (strncmp (p, "stoptime", p1 - p) == 0)
4003 p = unpack_varlen_hex (++p1, &val);
4004 ts->stop_time = val;
4006 else if (strncmp (p, "username", p1 - p) == 0)
4009 ts->user_name = xmalloc (strlen (p) / 2);
4010 end = hex2bin (p1, ts->user_name, (p3 - p1) / 2);
4011 ts->user_name[end] = '\0';
4014 else if (strncmp (p, "notes", p1 - p) == 0)
4017 ts->notes = xmalloc (strlen (p) / 2);
4018 end = hex2bin (p1, ts->notes, (p3 - p1) / 2);
4019 ts->notes[end] = '\0';
4024 /* Silently skip unknown optional info. */
4025 p_temp = strchr (p1 + 1, ';');
4029 /* Must be at the end. */
4036 parse_tracepoint_status (char *p, struct breakpoint *bp,
4037 struct uploaded_tp *utp)
4040 struct tracepoint *tp = (struct tracepoint *) bp;
4042 p = unpack_varlen_hex (p, &uval);
4044 tp->base.hit_count += uval;
4046 utp->hit_count += uval;
4047 p = unpack_varlen_hex (p + 1, &uval);
4049 tp->traceframe_usage += uval;
4051 utp->traceframe_usage += uval;
4052 /* Ignore any extra, allowing for future extensions. */
4055 /* Given a line of text defining a part of a tracepoint, parse it into
4056 an "uploaded tracepoint". */
4059 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
4063 ULONGEST num, addr, step, pass, orig_size, xlen, start;
4066 char *cond, *srctype, *buf;
4067 struct uploaded_tp *utp = NULL;
4070 /* Both tracepoint and action definitions start with the same number
4071 and address sequence. */
4073 p = unpack_varlen_hex (p, &num);
4074 p++; /* skip a colon */
4075 p = unpack_varlen_hex (p, &addr);
4076 p++; /* skip a colon */
4079 enabled = (*p++ == 'E');
4080 p++; /* skip a colon */
4081 p = unpack_varlen_hex (p, &step);
4082 p++; /* skip a colon */
4083 p = unpack_varlen_hex (p, &pass);
4084 type = bp_tracepoint;
4086 /* Thumb through optional fields. */
4089 p++; /* skip a colon */
4092 type = bp_fast_tracepoint;
4094 p = unpack_varlen_hex (p, &orig_size);
4098 type = bp_static_tracepoint;
4104 p = unpack_varlen_hex (p, &xlen);
4105 p++; /* skip a comma */
4106 cond = (char *) xmalloc (2 * xlen + 1);
4107 strncpy (cond, p, 2 * xlen);
4108 cond[2 * xlen] = '\0';
4112 warning (_("Unrecognized char '%c' in tracepoint "
4113 "definition, skipping rest"), *p);
4115 utp = get_uploaded_tp (num, addr, utpp);
4117 utp->enabled = enabled;
4122 else if (piece == 'A')
4124 utp = get_uploaded_tp (num, addr, utpp);
4125 VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
4127 else if (piece == 'S')
4129 utp = get_uploaded_tp (num, addr, utpp);
4130 VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
4132 else if (piece == 'Z')
4134 /* Parse a chunk of source form definition. */
4135 utp = get_uploaded_tp (num, addr, utpp);
4137 p = strchr (p, ':');
4138 p++; /* skip a colon */
4139 p = unpack_varlen_hex (p, &start);
4140 p++; /* skip a colon */
4141 p = unpack_varlen_hex (p, &xlen);
4142 p++; /* skip a colon */
4144 buf = alloca (strlen (line));
4146 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
4149 if (strncmp (srctype, "at:", strlen ("at:")) == 0)
4150 utp->at_string = xstrdup (buf);
4151 else if (strncmp (srctype, "cond:", strlen ("cond:")) == 0)
4152 utp->cond_string = xstrdup (buf);
4153 else if (strncmp (srctype, "cmd:", strlen ("cmd:")) == 0)
4154 VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
4156 else if (piece == 'V')
4158 utp = get_uploaded_tp (num, addr, utpp);
4160 parse_tracepoint_status (p, NULL, utp);
4164 /* Don't error out, the target might be sending us optional
4165 info that we don't care about. */
4166 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
4170 /* Convert a textual description of a trace state variable into an
4174 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
4177 ULONGEST num, initval, builtin;
4179 struct uploaded_tsv *utsv = NULL;
4181 buf = alloca (strlen (line));
4184 p = unpack_varlen_hex (p, &num);
4185 p++; /* skip a colon */
4186 p = unpack_varlen_hex (p, &initval);
4187 p++; /* skip a colon */
4188 p = unpack_varlen_hex (p, &builtin);
4189 p++; /* skip a colon */
4190 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
4193 utsv = get_uploaded_tsv (num, utsvp);
4194 utsv->initial_value = initval;
4195 utsv->builtin = builtin;
4196 utsv->name = xstrdup (buf);
4199 /* Close the trace file and generally clean up. */
4202 tfile_close (int quitting)
4209 pid = ptid_get_pid (inferior_ptid);
4210 inferior_ptid = null_ptid; /* Avoid confusion from thread stuff. */
4211 exit_inferior_silent (pid);
4215 xfree (trace_filename);
4216 trace_filename = NULL;
4220 tfile_files_info (struct target_ops *t)
4222 printf_filtered ("\t`%s'\n", trace_filename);
4225 /* The trace status for a file is that tracing can never be run. */
4228 tfile_get_trace_status (struct trace_status *ts)
4230 /* Other bits of trace status were collected as part of opening the
4231 trace files, so nothing to do here. */
4237 tfile_get_tracepoint_status (struct breakpoint *tp, struct uploaded_tp *utp)
4239 /* Other bits of trace status were collected as part of opening the
4240 trace files, so nothing to do here. */
4243 /* Given the position of a traceframe in the file, figure out what
4244 address the frame was collected at. This would normally be the
4245 value of a collected PC register, but if not available, we
4249 tfile_get_traceframe_address (off_t tframe_offset)
4253 struct tracepoint *tp;
4254 off_t saved_offset = cur_offset;
4256 /* FIXME dig pc out of collected registers. */
4258 /* Fall back to using tracepoint address. */
4259 lseek (trace_fd, tframe_offset, SEEK_SET);
4260 tfile_read ((gdb_byte *) &tpnum, 2);
4261 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
4263 (target_gdbarch ()));
4265 tp = get_tracepoint_by_number_on_target (tpnum);
4266 /* FIXME this is a poor heuristic if multiple locations. */
4267 if (tp && tp->base.loc)
4268 addr = tp->base.loc->address;
4270 /* Restore our seek position. */
4271 cur_offset = saved_offset;
4272 lseek (trace_fd, cur_offset, SEEK_SET);
4276 /* Given a type of search and some parameters, scan the collection of
4277 traceframes in the file looking for a match. When found, return
4278 both the traceframe and tracepoint number, otherwise -1 for
4282 tfile_trace_find (enum trace_find_type type, int num,
4283 ULONGEST addr1, ULONGEST addr2, int *tpp)
4286 int tfnum = 0, found = 0;
4287 unsigned int data_size;
4288 struct tracepoint *tp;
4289 off_t offset, tframe_offset;
4299 lseek (trace_fd, trace_frames_offset, SEEK_SET);
4300 offset = trace_frames_offset;
4303 tframe_offset = offset;
4304 tfile_read ((gdb_byte *) &tpnum, 2);
4305 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
4307 (target_gdbarch ()));
4311 tfile_read ((gdb_byte *) &data_size, 4);
4312 data_size = (unsigned int) extract_unsigned_integer
4313 ((gdb_byte *) &data_size, 4,
4314 gdbarch_byte_order (target_gdbarch ()));
4317 if (type == tfind_number)
4319 /* Looking for a specific trace frame. */
4325 /* Start from the _next_ trace frame. */
4326 if (tfnum > traceframe_number)
4331 tfaddr = tfile_get_traceframe_address (tframe_offset);
4332 if (tfaddr == addr1)
4336 tp = get_tracepoint (num);
4337 if (tp && tpnum == tp->number_on_target)
4341 tfaddr = tfile_get_traceframe_address (tframe_offset);
4342 if (addr1 <= tfaddr && tfaddr <= addr2)
4346 tfaddr = tfile_get_traceframe_address (tframe_offset);
4347 if (!(addr1 <= tfaddr && tfaddr <= addr2))
4351 internal_error (__FILE__, __LINE__, _("unknown tfind type"));
4360 cur_offset = offset;
4361 cur_data_size = data_size;
4365 /* Skip past the traceframe's data. */
4366 lseek (trace_fd, data_size, SEEK_CUR);
4367 offset += data_size;
4368 /* Update our own count of traceframes. */
4371 /* Did not find what we were looking for. */
4377 /* Prototype of the callback passed to tframe_walk_blocks. */
4378 typedef int (*walk_blocks_callback_func) (char blocktype, void *data);
4380 /* Callback for traceframe_walk_blocks, used to find a given block
4381 type in a traceframe. */
4384 match_blocktype (char blocktype, void *data)
4386 char *wantedp = data;
4388 if (*wantedp == blocktype)
4394 /* Walk over all traceframe block starting at POS offset from
4395 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4396 unmodified. If CALLBACK returns true, this returns the position in
4397 the traceframe where the block is found, relative to the start of
4398 the traceframe (cur_offset). Returns -1 if no callback call
4399 returned true, indicating that all blocks have been walked. */
4402 traceframe_walk_blocks (walk_blocks_callback_func callback,
4403 int pos, void *data)
4405 /* Iterate through a traceframe's blocks, looking for a block of the
4408 lseek (trace_fd, cur_offset + pos, SEEK_SET);
4409 while (pos < cur_data_size)
4411 unsigned short mlen;
4414 tfile_read (&block_type, 1);
4418 if ((*callback) (block_type, data))
4424 lseek (trace_fd, cur_offset + pos + trace_regblock_size, SEEK_SET);
4425 pos += trace_regblock_size;
4428 lseek (trace_fd, cur_offset + pos + 8, SEEK_SET);
4429 tfile_read ((gdb_byte *) &mlen, 2);
4430 mlen = (unsigned short)
4431 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
4433 (target_gdbarch ()));
4434 lseek (trace_fd, mlen, SEEK_CUR);
4435 pos += (8 + 2 + mlen);
4438 lseek (trace_fd, cur_offset + pos + 4 + 8, SEEK_SET);
4442 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4443 block_type, block_type);
4451 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4452 position offset of a block of type TYPE_WANTED in the current trace
4453 frame, starting at POS. Returns -1 if no such block was found. */
4456 traceframe_find_block_type (char type_wanted, int pos)
4458 return traceframe_walk_blocks (match_blocktype, pos, &type_wanted);
4461 /* Look for a block of saved registers in the traceframe, and get the
4462 requested register from it. */
4465 tfile_fetch_registers (struct target_ops *ops,
4466 struct regcache *regcache, int regno)
4468 struct gdbarch *gdbarch = get_regcache_arch (regcache);
4469 int offset, regn, regsize, pc_regno;
4472 /* An uninitialized reg size says we're not going to be
4473 successful at getting register blocks. */
4474 if (!trace_regblock_size)
4477 regs = alloca (trace_regblock_size);
4479 if (traceframe_find_block_type ('R', 0) >= 0)
4481 tfile_read (regs, trace_regblock_size);
4483 /* Assume the block is laid out in GDB register number order,
4484 each register with the size that it has in GDB. */
4486 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
4488 regsize = register_size (gdbarch, regn);
4489 /* Make sure we stay within block bounds. */
4490 if (offset + regsize >= trace_regblock_size)
4492 if (regcache_register_status (regcache, regn) == REG_UNKNOWN)
4496 regcache_raw_supply (regcache, regno, regs + offset);
4499 else if (regno == -1)
4501 regcache_raw_supply (regcache, regn, regs + offset);
4509 /* We get here if no register data has been found. Mark registers
4511 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
4512 regcache_raw_supply (regcache, regn, NULL);
4514 /* We can often usefully guess that the PC is going to be the same
4515 as the address of the tracepoint. */
4516 pc_regno = gdbarch_pc_regnum (gdbarch);
4517 if (pc_regno >= 0 && (regno == -1 || regno == pc_regno))
4519 struct tracepoint *tp = get_tracepoint (tracepoint_number);
4521 if (tp && tp->base.loc)
4523 /* But don't try to guess if tracepoint is multi-location... */
4524 if (tp->base.loc->next)
4526 warning (_("Tracepoint %d has multiple "
4527 "locations, cannot infer $pc"),
4531 /* ... or does while-stepping. */
4532 if (tp->step_count > 0)
4534 warning (_("Tracepoint %d does while-stepping, "
4535 "cannot infer $pc"),
4540 store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
4541 gdbarch_byte_order (gdbarch),
4542 tp->base.loc->address);
4543 regcache_raw_supply (regcache, pc_regno, regs);
4549 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
4550 const char *annex, gdb_byte *readbuf,
4551 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
4553 /* We're only doing regular memory for now. */
4554 if (object != TARGET_OBJECT_MEMORY)
4557 if (readbuf == NULL)
4558 error (_("tfile_xfer_partial: trace file is read-only"));
4560 if (traceframe_number != -1)
4564 /* Iterate through the traceframe's blocks, looking for
4566 while ((pos = traceframe_find_block_type ('M', pos)) >= 0)
4568 ULONGEST maddr, amt;
4569 unsigned short mlen;
4570 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
4572 tfile_read ((gdb_byte *) &maddr, 8);
4573 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
4575 tfile_read ((gdb_byte *) &mlen, 2);
4576 mlen = (unsigned short)
4577 extract_unsigned_integer ((gdb_byte *) &mlen, 2, byte_order);
4579 /* If the block includes the first part of the desired
4580 range, return as much it has; GDB will re-request the
4581 remainder, which might be in a different block of this
4583 if (maddr <= offset && offset < (maddr + mlen))
4585 amt = (maddr + mlen) - offset;
4589 if (maddr != offset)
4590 lseek (trace_fd, offset - maddr, SEEK_CUR);
4591 tfile_read (readbuf, amt);
4595 /* Skip over this block. */
4596 pos += (8 + 2 + mlen);
4600 /* It's unduly pedantic to refuse to look at the executable for
4601 read-only pieces; so do the equivalent of readonly regions aka
4603 /* FIXME account for relocation at some point. */
4610 for (s = exec_bfd->sections; s; s = s->next)
4612 if ((s->flags & SEC_LOAD) == 0
4613 || (s->flags & SEC_READONLY) == 0)
4617 size = bfd_get_section_size (s);
4618 if (vma <= offset && offset < (vma + size))
4622 amt = (vma + size) - offset;
4626 amt = bfd_get_section_contents (exec_bfd, s,
4627 readbuf, offset - vma, amt);
4633 /* Indicate failure to find the requested memory block. */
4637 /* Iterate through the blocks of a trace frame, looking for a 'V'
4638 block with a matching tsv number. */
4641 tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
4646 while ((pos = traceframe_find_block_type ('V', pos)) >= 0)
4650 tfile_read ((gdb_byte *) &vnum, 4);
4651 vnum = (int) extract_signed_integer ((gdb_byte *) &vnum, 4,
4653 (target_gdbarch ()));
4656 tfile_read ((gdb_byte *) val, 8);
4657 *val = extract_signed_integer ((gdb_byte *) val, 8,
4659 (target_gdbarch ()));
4665 /* Didn't find anything. */
4670 tfile_has_all_memory (struct target_ops *ops)
4676 tfile_has_memory (struct target_ops *ops)
4682 tfile_has_stack (struct target_ops *ops)
4684 return traceframe_number != -1;
4688 tfile_has_registers (struct target_ops *ops)
4690 return traceframe_number != -1;
4694 tfile_thread_alive (struct target_ops *ops, ptid_t ptid)
4699 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
4700 object for the tfile target's current traceframe. */
4703 build_traceframe_info (char blocktype, void *data)
4705 struct traceframe_info *info = data;
4711 struct mem_range *r;
4713 unsigned short mlen;
4715 tfile_read ((gdb_byte *) &maddr, 8);
4716 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
4718 (target_gdbarch ()));
4719 tfile_read ((gdb_byte *) &mlen, 2);
4720 mlen = (unsigned short)
4721 extract_unsigned_integer ((gdb_byte *) &mlen,
4722 2, gdbarch_byte_order
4723 (target_gdbarch ()));
4725 r = VEC_safe_push (mem_range_s, info->memory, NULL);
4738 warning (_("Unhandled trace block type (%d) '%c ' "
4739 "while building trace frame info."),
4740 blocktype, blocktype);
4747 static struct traceframe_info *
4748 tfile_traceframe_info (void)
4750 struct traceframe_info *info = XCNEW (struct traceframe_info);
4752 traceframe_walk_blocks (build_traceframe_info, 0, info);
4757 init_tfile_ops (void)
4759 tfile_ops.to_shortname = "tfile";
4760 tfile_ops.to_longname = "Local trace dump file";
4762 = "Use a trace file as a target. Specify the filename of the trace file.";
4763 tfile_ops.to_open = tfile_open;
4764 tfile_ops.to_close = tfile_close;
4765 tfile_ops.to_fetch_registers = tfile_fetch_registers;
4766 tfile_ops.to_xfer_partial = tfile_xfer_partial;
4767 tfile_ops.to_files_info = tfile_files_info;
4768 tfile_ops.to_get_trace_status = tfile_get_trace_status;
4769 tfile_ops.to_get_tracepoint_status = tfile_get_tracepoint_status;
4770 tfile_ops.to_trace_find = tfile_trace_find;
4771 tfile_ops.to_get_trace_state_variable_value
4772 = tfile_get_trace_state_variable_value;
4773 tfile_ops.to_stratum = process_stratum;
4774 tfile_ops.to_has_all_memory = tfile_has_all_memory;
4775 tfile_ops.to_has_memory = tfile_has_memory;
4776 tfile_ops.to_has_stack = tfile_has_stack;
4777 tfile_ops.to_has_registers = tfile_has_registers;
4778 tfile_ops.to_traceframe_info = tfile_traceframe_info;
4779 tfile_ops.to_thread_alive = tfile_thread_alive;
4780 tfile_ops.to_magic = OPS_MAGIC;
4784 free_current_marker (void *arg)
4786 struct static_tracepoint_marker **marker_p = arg;
4788 if (*marker_p != NULL)
4790 release_static_tracepoint_marker (*marker_p);
4797 /* Given a line of text defining a static tracepoint marker, parse it
4798 into a "static tracepoint marker" object. Throws an error is
4799 parsing fails. If PP is non-null, it points to one past the end of
4800 the parsed marker definition. */
4803 parse_static_tracepoint_marker_definition (char *line, char **pp,
4804 struct static_tracepoint_marker *marker)
4811 p = unpack_varlen_hex (p, &addr);
4812 p++; /* skip a colon */
4814 marker->gdbarch = target_gdbarch ();
4815 marker->address = (CORE_ADDR) addr;
4817 endp = strchr (p, ':');
4819 error (_("bad marker definition: %s"), line);
4821 marker->str_id = xmalloc (endp - p + 1);
4822 end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
4823 marker->str_id[end] = '\0';
4826 p++; /* skip a colon */
4828 marker->extra = xmalloc (strlen (p) + 1);
4829 end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
4830 marker->extra[end] = '\0';
4836 /* Release a static tracepoint marker's contents. Note that the
4837 object itself isn't released here. There objects are usually on
4841 release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
4843 xfree (marker->str_id);
4844 marker->str_id = NULL;
4847 /* Print MARKER to gdb_stdout. */
4850 print_one_static_tracepoint_marker (int count,
4851 struct static_tracepoint_marker *marker)
4853 struct command_line *l;
4856 char wrap_indent[80];
4857 char extra_field_indent[80];
4858 struct ui_out *uiout = current_uiout;
4859 struct cleanup *bkpt_chain;
4860 VEC(breakpoint_p) *tracepoints;
4862 struct symtab_and_line sal;
4866 sal.pc = marker->address;
4868 tracepoints = static_tracepoints_here (marker->address);
4870 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "marker");
4872 /* A counter field to help readability. This is not a stable
4874 ui_out_field_int (uiout, "count", count);
4876 ui_out_field_string (uiout, "marker-id", marker->str_id);
4878 ui_out_field_fmt (uiout, "enabled", "%c",
4879 !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
4880 ui_out_spaces (uiout, 2);
4882 strcpy (wrap_indent, " ");
4884 if (gdbarch_addr_bit (marker->gdbarch) <= 32)
4885 strcat (wrap_indent, " ");
4887 strcat (wrap_indent, " ");
4889 strcpy (extra_field_indent, " ");
4891 ui_out_field_core_addr (uiout, "addr", marker->gdbarch, marker->address);
4893 sal = find_pc_line (marker->address, 0);
4894 sym = find_pc_sect_function (marker->address, NULL);
4897 ui_out_text (uiout, "in ");
4898 ui_out_field_string (uiout, "func",
4899 SYMBOL_PRINT_NAME (sym));
4900 ui_out_wrap_hint (uiout, wrap_indent);
4901 ui_out_text (uiout, " at ");
4904 ui_out_field_skip (uiout, "func");
4906 if (sal.symtab != NULL)
4908 ui_out_field_string (uiout, "file",
4909 symtab_to_filename_for_display (sal.symtab));
4910 ui_out_text (uiout, ":");
4912 if (ui_out_is_mi_like_p (uiout))
4914 const char *fullname = symtab_to_fullname (sal.symtab);
4916 ui_out_field_string (uiout, "fullname", fullname);
4919 ui_out_field_skip (uiout, "fullname");
4921 ui_out_field_int (uiout, "line", sal.line);
4925 ui_out_field_skip (uiout, "fullname");
4926 ui_out_field_skip (uiout, "line");
4929 ui_out_text (uiout, "\n");
4930 ui_out_text (uiout, extra_field_indent);
4931 ui_out_text (uiout, _("Data: \""));
4932 ui_out_field_string (uiout, "extra-data", marker->extra);
4933 ui_out_text (uiout, "\"\n");
4935 if (!VEC_empty (breakpoint_p, tracepoints))
4937 struct cleanup *cleanup_chain;
4939 struct breakpoint *b;
4941 cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
4944 ui_out_text (uiout, extra_field_indent);
4945 ui_out_text (uiout, _("Probed by static tracepoints: "));
4946 for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
4949 ui_out_text (uiout, ", ");
4950 ui_out_text (uiout, "#");
4951 ui_out_field_int (uiout, "tracepoint-id", b->number);
4954 do_cleanups (cleanup_chain);
4956 if (ui_out_is_mi_like_p (uiout))
4957 ui_out_field_int (uiout, "number-of-tracepoints",
4958 VEC_length(breakpoint_p, tracepoints));
4960 ui_out_text (uiout, "\n");
4962 VEC_free (breakpoint_p, tracepoints);
4964 do_cleanups (bkpt_chain);
4968 info_static_tracepoint_markers_command (char *arg, int from_tty)
4970 VEC(static_tracepoint_marker_p) *markers;
4971 struct cleanup *old_chain;
4972 struct static_tracepoint_marker *marker;
4973 struct ui_out *uiout = current_uiout;
4976 /* We don't have to check target_can_use_agent and agent's capability on
4977 static tracepoint here, in order to be compatible with older GDBserver.
4978 We don't check USE_AGENT is true or not, because static tracepoints
4979 don't work without in-process agent, so we don't bother users to type
4980 `set agent on' when to use static tracepoint. */
4983 = make_cleanup_ui_out_table_begin_end (uiout, 5, -1,
4984 "StaticTracepointMarkersTable");
4986 ui_out_table_header (uiout, 7, ui_left, "counter", "Cnt");
4988 ui_out_table_header (uiout, 40, ui_left, "marker-id", "ID");
4990 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
4991 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
4992 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");
4994 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
4995 ui_out_table_header (uiout, 40, ui_noalign, "what", "What");
4997 ui_out_table_body (uiout);
4999 markers = target_static_tracepoint_markers_by_strid (NULL);
5000 make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
5003 VEC_iterate (static_tracepoint_marker_p,
5004 markers, i, marker);
5007 print_one_static_tracepoint_marker (i + 1, marker);
5008 release_static_tracepoint_marker (marker);
5011 do_cleanups (old_chain);
5014 /* The $_sdata convenience variable is a bit special. We don't know
5015 for sure type of the value until we actually have a chance to fetch
5016 the data --- the size of the object depends on what has been
5017 collected. We solve this by making $_sdata be an internalvar that
5018 creates a new value on access. */
5020 /* Return a new value with the correct type for the sdata object of
5021 the current trace frame. Return a void value if there's no object
5024 static struct value *
5025 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var,
5031 /* We need to read the whole object before we know its size. */
5032 size = target_read_alloc (¤t_target,
5033 TARGET_OBJECT_STATIC_TRACE_DATA,
5040 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
5042 v = allocate_value (type);
5043 memcpy (value_contents_raw (v), buf, size);
5048 return allocate_value (builtin_type (gdbarch)->builtin_void);
5051 #if !defined(HAVE_LIBEXPAT)
5053 struct traceframe_info *
5054 parse_traceframe_info (const char *tframe_info)
5056 static int have_warned;
5061 warning (_("Can not parse XML trace frame info; XML support "
5062 "was disabled at compile time"));
5068 #else /* HAVE_LIBEXPAT */
5070 #include "xml-support.h"
5072 /* Handle the start of a <memory> element. */
5075 traceframe_info_start_memory (struct gdb_xml_parser *parser,
5076 const struct gdb_xml_element *element,
5077 void *user_data, VEC(gdb_xml_value_s) *attributes)
5079 struct traceframe_info *info = user_data;
5080 struct mem_range *r = VEC_safe_push (mem_range_s, info->memory, NULL);
5081 ULONGEST *start_p, *length_p;
5083 start_p = xml_find_attribute (attributes, "start")->value;
5084 length_p = xml_find_attribute (attributes, "length")->value;
5086 r->start = *start_p;
5087 r->length = *length_p;
5090 /* Discard the constructed trace frame info (if an error occurs). */
5093 free_result (void *p)
5095 struct traceframe_info *result = p;
5097 free_traceframe_info (result);
5100 /* The allowed elements and attributes for an XML memory map. */
5102 static const struct gdb_xml_attribute memory_attributes[] = {
5103 { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
5104 { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
5105 { NULL, GDB_XML_AF_NONE, NULL, NULL }
5108 static const struct gdb_xml_element traceframe_info_children[] = {
5109 { "memory", memory_attributes, NULL,
5110 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
5111 traceframe_info_start_memory, NULL },
5112 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
5115 static const struct gdb_xml_element traceframe_info_elements[] = {
5116 { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
5118 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
5121 /* Parse a traceframe-info XML document. */
5123 struct traceframe_info *
5124 parse_traceframe_info (const char *tframe_info)
5126 struct traceframe_info *result;
5127 struct cleanup *back_to;
5129 result = XCNEW (struct traceframe_info);
5130 back_to = make_cleanup (free_result, result);
5132 if (gdb_xml_parse_quick (_("trace frame info"),
5133 "traceframe-info.dtd", traceframe_info_elements,
5134 tframe_info, result) == 0)
5136 /* Parsed successfully, keep the result. */
5137 discard_cleanups (back_to);
5142 do_cleanups (back_to);
5146 #endif /* HAVE_LIBEXPAT */
5148 /* Returns the traceframe_info object for the current traceframe.
5149 This is where we avoid re-fetching the object from the target if we
5150 already have it cached. */
5152 static struct traceframe_info *
5153 get_traceframe_info (void)
5155 if (traceframe_info == NULL)
5156 traceframe_info = target_traceframe_info ();
5158 return traceframe_info;
5161 /* If the target supports the query, return in RESULT the set of
5162 collected memory in the current traceframe, found within the LEN
5163 bytes range starting at MEMADDR. Returns true if the target
5164 supports the query, otherwise returns false, and RESULT is left
5168 traceframe_available_memory (VEC(mem_range_s) **result,
5169 CORE_ADDR memaddr, ULONGEST len)
5171 struct traceframe_info *info = get_traceframe_info ();
5175 struct mem_range *r;
5180 for (i = 0; VEC_iterate (mem_range_s, info->memory, i, r); i++)
5181 if (mem_ranges_overlap (r->start, r->length, memaddr, len))
5183 ULONGEST lo1, hi1, lo2, hi2;
5184 struct mem_range *nr;
5187 hi1 = memaddr + len;
5190 hi2 = r->start + r->length;
5192 nr = VEC_safe_push (mem_range_s, *result, NULL);
5194 nr->start = max (lo1, lo2);
5195 nr->length = min (hi1, hi2) - nr->start;
5198 normalize_mem_ranges (*result);
5205 /* Implementation of `sdata' variable. */
5207 static const struct internalvar_funcs sdata_funcs =
5214 /* module initialization */
5216 _initialize_tracepoint (void)
5218 struct cmd_list_element *c;
5220 /* Explicitly create without lookup, since that tries to create a
5221 value with a void typed value, and when we get here, gdbarch
5222 isn't initialized yet. At this point, we're quite sure there
5223 isn't another convenience variable of the same name. */
5224 create_internalvar_type_lazy ("_sdata", &sdata_funcs, NULL);
5226 traceframe_number = -1;
5227 tracepoint_number = -1;
5229 if (tracepoint_list.list == NULL)
5231 tracepoint_list.listsize = 128;
5232 tracepoint_list.list = xmalloc
5233 (tracepoint_list.listsize * sizeof (struct memrange));
5235 if (tracepoint_list.aexpr_list == NULL)
5237 tracepoint_list.aexpr_listsize = 128;
5238 tracepoint_list.aexpr_list = xmalloc
5239 (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
5242 if (stepping_list.list == NULL)
5244 stepping_list.listsize = 128;
5245 stepping_list.list = xmalloc
5246 (stepping_list.listsize * sizeof (struct memrange));
5249 if (stepping_list.aexpr_list == NULL)
5251 stepping_list.aexpr_listsize = 128;
5252 stepping_list.aexpr_list = xmalloc
5253 (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
5256 add_info ("scope", scope_info,
5257 _("List the variables local to a scope"));
5259 add_cmd ("tracepoints", class_trace, NULL,
5260 _("Tracing of program execution without stopping the program."),
5263 add_com ("tdump", class_trace, trace_dump_command,
5264 _("Print everything collected at the current tracepoint."));
5266 add_com ("tsave", class_trace, trace_save_command, _("\
5267 Save the trace data to a file.\n\
5268 Use the '-r' option to direct the target to save directly to the file,\n\
5269 using its own filesystem."));
5271 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
5272 Define a trace state variable.\n\
5273 Argument is a $-prefixed name, optionally followed\n\
5274 by '=' and an expression that sets the initial value\n\
5275 at the start of tracing."));
5276 set_cmd_completer (c, expression_completer);
5278 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
5279 Delete one or more trace state variables.\n\
5280 Arguments are the names of the variables to delete.\n\
5281 If no arguments are supplied, delete all variables."), &deletelist);
5282 /* FIXME add a trace variable completer. */
5284 add_info ("tvariables", tvariables_info, _("\
5285 Status of trace state variables and their values.\n\
5288 add_info ("static-tracepoint-markers",
5289 info_static_tracepoint_markers_command, _("\
5290 List target static tracepoints markers.\n\
5293 add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
5294 Select a trace frame;\n\
5295 No argument means forward by one frame; '-' means backward by one frame."),
5296 &tfindlist, "tfind ", 1, &cmdlist);
5298 add_cmd ("outside", class_trace, trace_find_outside_command, _("\
5299 Select a trace frame whose PC is outside the given range (exclusive).\n\
5300 Usage: tfind outside addr1, addr2"),
5303 add_cmd ("range", class_trace, trace_find_range_command, _("\
5304 Select a trace frame whose PC is in the given range (inclusive).\n\
5305 Usage: tfind range addr1,addr2"),
5308 add_cmd ("line", class_trace, trace_find_line_command, _("\
5309 Select a trace frame by source line.\n\
5310 Argument can be a line number (with optional source file),\n\
5311 a function name, or '*' followed by an address.\n\
5312 Default argument is 'the next source line that was traced'."),
5315 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
5316 Select a trace frame by tracepoint number.\n\
5317 Default is the tracepoint for the current trace frame."),
5320 add_cmd ("pc", class_trace, trace_find_pc_command, _("\
5321 Select a trace frame by PC.\n\
5322 Default is the current PC, or the PC of the current trace frame."),
5325 add_cmd ("end", class_trace, trace_find_end_command, _("\
5326 De-select any trace frame and resume 'live' debugging."),
5329 add_alias_cmd ("none", "end", class_trace, 0, &tfindlist);
5331 add_cmd ("start", class_trace, trace_find_start_command,
5332 _("Select the first trace frame in the trace buffer."),
5335 add_com ("tstatus", class_trace, trace_status_command,
5336 _("Display the status of the current trace data collection."));
5338 add_com ("tstop", class_trace, trace_stop_command, _("\
5339 Stop trace data collection.\n\
5340 Usage: tstop [ <notes> ... ]\n\
5341 Any arguments supplied are recorded with the trace as a stop reason and\n\
5342 reported by tstatus (if the target supports trace notes)."));
5344 add_com ("tstart", class_trace, trace_start_command, _("\
5345 Start trace data collection.\n\
5346 Usage: tstart [ <notes> ... ]\n\
5347 Any arguments supplied are recorded with the trace as a note and\n\
5348 reported by tstatus (if the target supports trace notes)."));
5350 add_com ("end", class_trace, end_actions_pseudocommand, _("\
5351 Ends a list of commands or actions.\n\
5352 Several GDB commands allow you to enter a list of commands or actions.\n\
5353 Entering \"end\" on a line by itself is the normal way to terminate\n\
5355 Note: the \"end\" command cannot be used at the gdb prompt."));
5357 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
5358 Specify single-stepping behavior at a tracepoint.\n\
5359 Argument is number of instructions to trace in single-step mode\n\
5360 following the tracepoint. This command is normally followed by\n\
5361 one or more \"collect\" commands, to specify what to collect\n\
5362 while single-stepping.\n\n\
5363 Note: this command can only be used in a tracepoint \"actions\" list."));
5365 add_com_alias ("ws", "while-stepping", class_alias, 0);
5366 add_com_alias ("stepping", "while-stepping", class_alias, 0);
5368 add_com ("collect", class_trace, collect_pseudocommand, _("\
5369 Specify one or more data items to be collected at a tracepoint.\n\
5370 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5371 collect all data (variables, registers) referenced by that expression.\n\
5372 Also accepts the following special arguments:\n\
5373 $regs -- all registers.\n\
5374 $args -- all function arguments.\n\
5375 $locals -- all variables local to the block/function scope.\n\
5376 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5377 Note: this command can only be used in a tracepoint \"actions\" list."));
5379 add_com ("teval", class_trace, teval_pseudocommand, _("\
5380 Specify one or more expressions to be evaluated at a tracepoint.\n\
5381 Accepts a comma-separated list of (one or more) expressions.\n\
5382 The result of each evaluation will be discarded.\n\
5383 Note: this command can only be used in a tracepoint \"actions\" list."));
5385 add_com ("actions", class_trace, trace_actions_command, _("\
5386 Specify the actions to be taken at a tracepoint.\n\
5387 Tracepoint actions may include collecting of specified data,\n\
5388 single-stepping, or enabling/disabling other tracepoints,\n\
5389 depending on target's capabilities."));
5391 default_collect = xstrdup ("");
5392 add_setshow_string_cmd ("default-collect", class_trace,
5393 &default_collect, _("\
5394 Set the list of expressions to collect by default"), _("\
5395 Show the list of expressions to collect by default"), NULL,
5397 &setlist, &showlist);
5399 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
5400 &disconnected_tracing, _("\
5401 Set whether tracing continues after GDB disconnects."), _("\
5402 Show whether tracing continues after GDB disconnects."), _("\
5403 Use this to continue a tracing run even if GDB disconnects\n\
5404 or detaches from the target. You can reconnect later and look at\n\
5405 trace data collected in the meantime."),
5406 set_disconnected_tracing,
5411 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
5412 &circular_trace_buffer, _("\
5413 Set target's use of circular trace buffer."), _("\
5414 Show target's use of circular trace buffer."), _("\
5415 Use this to make the trace buffer into a circular buffer,\n\
5416 which will discard traceframes (oldest first) instead of filling\n\
5417 up and stopping the trace run."),
5418 set_circular_trace_buffer,
5423 add_setshow_string_cmd ("trace-user", class_trace,
5425 Set the user name to use for current and future trace runs"), _("\
5426 Show the user name to use for current and future trace runs"), NULL,
5427 set_trace_user, NULL,
5428 &setlist, &showlist);
5430 add_setshow_string_cmd ("trace-notes", class_trace,
5432 Set notes string to use for current and future trace runs"), _("\
5433 Show the notes string to use for current and future trace runs"), NULL,
5434 set_trace_notes, NULL,
5435 &setlist, &showlist);
5437 add_setshow_string_cmd ("trace-stop-notes", class_trace,
5438 &trace_stop_notes, _("\
5439 Set notes string to use for future tstop commands"), _("\
5440 Show the notes string to use for future tstop commands"), NULL,
5441 set_trace_stop_notes, NULL,
5442 &setlist, &showlist);
5446 add_target (&tfile_ops);