gdb/
[binutils-gdb.git] / gdb / tracepoint.c
1 /* Tracing functionality for remote targets in custom GDB protocol
2
3 Copyright (C) 1997-2013 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20 #include "defs.h"
21 #include "arch-utils.h"
22 #include "symtab.h"
23 #include "frame.h"
24 #include "gdbtypes.h"
25 #include "expression.h"
26 #include "gdbcmd.h"
27 #include "value.h"
28 #include "target.h"
29 #include "language.h"
30 #include "gdb_string.h"
31 #include "inferior.h"
32 #include "breakpoint.h"
33 #include "tracepoint.h"
34 #include "linespec.h"
35 #include "regcache.h"
36 #include "completer.h"
37 #include "block.h"
38 #include "dictionary.h"
39 #include "observer.h"
40 #include "user-regs.h"
41 #include "valprint.h"
42 #include "gdbcore.h"
43 #include "objfiles.h"
44 #include "filenames.h"
45 #include "gdbthread.h"
46 #include "stack.h"
47 #include "gdbcore.h"
48 #include "remote.h"
49 #include "source.h"
50 #include "ax.h"
51 #include "ax-gdb.h"
52 #include "memrange.h"
53 #include "exceptions.h"
54 #include "cli/cli-utils.h"
55 #include "probe.h"
56 #include "ctf.h"
57
58 /* readline include files */
59 #include "readline/readline.h"
60 #include "readline/history.h"
61
62 /* readline defines this. */
63 #undef savestring
64
65 #ifdef HAVE_UNISTD_H
66 #include <unistd.h>
67 #endif
68
69 #ifndef O_LARGEFILE
70 #define O_LARGEFILE 0
71 #endif
72
73 /* Maximum length of an agent aexpression.
74 This accounts for the fact that packets are limited to 400 bytes
75 (which includes everything -- including the checksum), and assumes
76 the worst case of maximum length for each of the pieces of a
77 continuation packet.
78
79 NOTE: expressions get mem2hex'ed otherwise this would be twice as
80 large. (400 - 31)/2 == 184 */
81 #define MAX_AGENT_EXPR_LEN 184
82
83 #define TFILE_PID (1)
84
85 /* A hook used to notify the UI of tracepoint operations. */
86
87 void (*deprecated_trace_find_hook) (char *arg, int from_tty);
88 void (*deprecated_trace_start_stop_hook) (int start, int from_tty);
89
90 extern void (*deprecated_readline_begin_hook) (char *, ...);
91 extern char *(*deprecated_readline_hook) (char *);
92 extern void (*deprecated_readline_end_hook) (void);
93
94 /*
95 Tracepoint.c:
96
97 This module defines the following debugger commands:
98 trace : set a tracepoint on a function, line, or address.
99 info trace : list all debugger-defined tracepoints.
100 delete trace : delete one or more tracepoints.
101 enable trace : enable one or more tracepoints.
102 disable trace : disable one or more tracepoints.
103 actions : specify actions to be taken at a tracepoint.
104 passcount : specify a pass count for a tracepoint.
105 tstart : start a trace experiment.
106 tstop : stop a trace experiment.
107 tstatus : query the status of a trace experiment.
108 tfind : find a trace frame in the trace buffer.
109 tdump : print everything collected at the current tracepoint.
110 save-tracepoints : write tracepoint setup into a file.
111
112 This module defines the following user-visible debugger variables:
113 $trace_frame : sequence number of trace frame currently being debugged.
114 $trace_line : source line of trace frame currently being debugged.
115 $trace_file : source file of trace frame currently being debugged.
116 $tracepoint : tracepoint number of trace frame currently being debugged.
117 */
118
119
120 /* ======= Important global variables: ======= */
121
122 /* The list of all trace state variables. We don't retain pointers to
123 any of these for any reason - API is by name or number only - so it
124 works to have a vector of objects. */
125
126 typedef struct trace_state_variable tsv_s;
127 DEF_VEC_O(tsv_s);
128
129 /* An object describing the contents of a traceframe. */
130
131 struct traceframe_info
132 {
133 /* Collected memory. */
134 VEC(mem_range_s) *memory;
135 };
136
137 static VEC(tsv_s) *tvariables;
138
139 /* The next integer to assign to a variable. */
140
141 static int next_tsv_number = 1;
142
143 /* Number of last traceframe collected. */
144 static int traceframe_number;
145
146 /* Tracepoint for last traceframe collected. */
147 static int tracepoint_number;
148
149 /* Symbol for function for last traceframe collected. */
150 static struct symbol *traceframe_fun;
151
152 /* Symtab and line for last traceframe collected. */
153 static struct symtab_and_line traceframe_sal;
154
155 /* The traceframe info of the current traceframe. NULL if we haven't
156 yet attempted to fetch it, or if the target does not support
157 fetching this object, or if we're not inspecting a traceframe
158 presently. */
159 static struct traceframe_info *traceframe_info;
160
161 /* Tracing command lists. */
162 static struct cmd_list_element *tfindlist;
163
164 /* List of expressions to collect by default at each tracepoint hit. */
165 char *default_collect = "";
166
167 static int disconnected_tracing;
168
169 /* This variable controls whether we ask the target for a linear or
170 circular trace buffer. */
171
172 static int circular_trace_buffer;
173
174 /* This variable is the requested trace buffer size, or -1 to indicate
175 that we don't care and leave it up to the target to set a size. */
176
177 static int trace_buffer_size = -1;
178
179 /* Textual notes applying to the current and/or future trace runs. */
180
181 char *trace_user = NULL;
182
183 /* Textual notes applying to the current and/or future trace runs. */
184
185 char *trace_notes = NULL;
186
187 /* Textual notes applying to the stopping of a trace. */
188
189 char *trace_stop_notes = NULL;
190
191 /* ======= Important command functions: ======= */
192 static void trace_actions_command (char *, int);
193 static void trace_start_command (char *, int);
194 static void trace_stop_command (char *, int);
195 static void trace_status_command (char *, int);
196 static void trace_find_command (char *, int);
197 static void trace_find_pc_command (char *, int);
198 static void trace_find_tracepoint_command (char *, int);
199 static void trace_find_line_command (char *, int);
200 static void trace_find_range_command (char *, int);
201 static void trace_find_outside_command (char *, int);
202 static void trace_dump_command (char *, int);
203
204 /* support routines */
205
206 struct collection_list;
207 static void add_aexpr (struct collection_list *, struct agent_expr *);
208 static char *mem2hex (gdb_byte *, char *, int);
209 static void add_register (struct collection_list *collection,
210 unsigned int regno);
211
212 static void free_uploaded_tps (struct uploaded_tp **utpp);
213 static void free_uploaded_tsvs (struct uploaded_tsv **utsvp);
214
215
216 extern void _initialize_tracepoint (void);
217
218 static struct trace_status trace_status;
219
220 char *stop_reason_names[] = {
221 "tunknown",
222 "tnotrun",
223 "tstop",
224 "tfull",
225 "tdisconnected",
226 "tpasscount",
227 "terror"
228 };
229
230 struct trace_status *
231 current_trace_status (void)
232 {
233 return &trace_status;
234 }
235
236 /* Destroy INFO. */
237
238 static void
239 free_traceframe_info (struct traceframe_info *info)
240 {
241 if (info != NULL)
242 {
243 VEC_free (mem_range_s, info->memory);
244
245 xfree (info);
246 }
247 }
248
249 /* Free and clear the traceframe info cache of the current
250 traceframe. */
251
252 static void
253 clear_traceframe_info (void)
254 {
255 free_traceframe_info (traceframe_info);
256 traceframe_info = NULL;
257 }
258
259 /* Set traceframe number to NUM. */
260 static void
261 set_traceframe_num (int num)
262 {
263 traceframe_number = num;
264 set_internalvar_integer (lookup_internalvar ("trace_frame"), num);
265 }
266
267 /* Set tracepoint number to NUM. */
268 static void
269 set_tracepoint_num (int num)
270 {
271 tracepoint_number = num;
272 set_internalvar_integer (lookup_internalvar ("tracepoint"), num);
273 }
274
275 /* Set externally visible debug variables for querying/printing
276 the traceframe context (line, function, file). */
277
278 static void
279 set_traceframe_context (struct frame_info *trace_frame)
280 {
281 CORE_ADDR trace_pc;
282
283 /* Save as globals for internal use. */
284 if (trace_frame != NULL
285 && get_frame_pc_if_available (trace_frame, &trace_pc))
286 {
287 traceframe_sal = find_pc_line (trace_pc, 0);
288 traceframe_fun = find_pc_function (trace_pc);
289
290 /* Save linenumber as "$trace_line", a debugger variable visible to
291 users. */
292 set_internalvar_integer (lookup_internalvar ("trace_line"),
293 traceframe_sal.line);
294 }
295 else
296 {
297 init_sal (&traceframe_sal);
298 traceframe_fun = NULL;
299 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
300 }
301
302 /* Save func name as "$trace_func", a debugger variable visible to
303 users. */
304 if (traceframe_fun == NULL
305 || SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL)
306 clear_internalvar (lookup_internalvar ("trace_func"));
307 else
308 set_internalvar_string (lookup_internalvar ("trace_func"),
309 SYMBOL_LINKAGE_NAME (traceframe_fun));
310
311 /* Save file name as "$trace_file", a debugger variable visible to
312 users. */
313 if (traceframe_sal.symtab == NULL)
314 clear_internalvar (lookup_internalvar ("trace_file"));
315 else
316 set_internalvar_string (lookup_internalvar ("trace_file"),
317 symtab_to_filename_for_display (traceframe_sal.symtab));
318 }
319
320 /* Create a new trace state variable with the given name. */
321
322 struct trace_state_variable *
323 create_trace_state_variable (const char *name)
324 {
325 struct trace_state_variable tsv;
326
327 memset (&tsv, 0, sizeof (tsv));
328 tsv.name = xstrdup (name);
329 tsv.number = next_tsv_number++;
330 return VEC_safe_push (tsv_s, tvariables, &tsv);
331 }
332
333 /* Look for a trace state variable of the given name. */
334
335 struct trace_state_variable *
336 find_trace_state_variable (const char *name)
337 {
338 struct trace_state_variable *tsv;
339 int ix;
340
341 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
342 if (strcmp (name, tsv->name) == 0)
343 return tsv;
344
345 return NULL;
346 }
347
348 static void
349 delete_trace_state_variable (const char *name)
350 {
351 struct trace_state_variable *tsv;
352 int ix;
353
354 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
355 if (strcmp (name, tsv->name) == 0)
356 {
357 observer_notify_tsv_deleted (tsv);
358
359 xfree ((void *)tsv->name);
360 VEC_unordered_remove (tsv_s, tvariables, ix);
361
362 return;
363 }
364
365 warning (_("No trace variable named \"$%s\", not deleting"), name);
366 }
367
368 /* Throws an error if NAME is not valid syntax for a trace state
369 variable's name. */
370
371 void
372 validate_trace_state_variable_name (const char *name)
373 {
374 const char *p;
375
376 if (*name == '\0')
377 error (_("Must supply a non-empty variable name"));
378
379 /* All digits in the name is reserved for value history
380 references. */
381 for (p = name; isdigit (*p); p++)
382 ;
383 if (*p == '\0')
384 error (_("$%s is not a valid trace state variable name"), name);
385
386 for (p = name; isalnum (*p) || *p == '_'; p++)
387 ;
388 if (*p != '\0')
389 error (_("$%s is not a valid trace state variable name"), name);
390 }
391
392 /* The 'tvariable' command collects a name and optional expression to
393 evaluate into an initial value. */
394
395 static void
396 trace_variable_command (char *args, int from_tty)
397 {
398 struct cleanup *old_chain;
399 LONGEST initval = 0;
400 struct trace_state_variable *tsv;
401 char *name, *p;
402
403 if (!args || !*args)
404 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
405
406 /* Only allow two syntaxes; "$name" and "$name=value". */
407 p = skip_spaces (args);
408
409 if (*p++ != '$')
410 error (_("Name of trace variable should start with '$'"));
411
412 name = p;
413 while (isalnum (*p) || *p == '_')
414 p++;
415 name = savestring (name, p - name);
416 old_chain = make_cleanup (xfree, name);
417
418 p = skip_spaces (p);
419 if (*p != '=' && *p != '\0')
420 error (_("Syntax must be $NAME [ = EXPR ]"));
421
422 validate_trace_state_variable_name (name);
423
424 if (*p == '=')
425 initval = value_as_long (parse_and_eval (++p));
426
427 /* If the variable already exists, just change its initial value. */
428 tsv = find_trace_state_variable (name);
429 if (tsv)
430 {
431 if (tsv->initial_value != initval)
432 {
433 tsv->initial_value = initval;
434 observer_notify_tsv_modified (tsv);
435 }
436 printf_filtered (_("Trace state variable $%s "
437 "now has initial value %s.\n"),
438 tsv->name, plongest (tsv->initial_value));
439 do_cleanups (old_chain);
440 return;
441 }
442
443 /* Create a new variable. */
444 tsv = create_trace_state_variable (name);
445 tsv->initial_value = initval;
446
447 observer_notify_tsv_created (tsv);
448
449 printf_filtered (_("Trace state variable $%s "
450 "created, with initial value %s.\n"),
451 tsv->name, plongest (tsv->initial_value));
452
453 do_cleanups (old_chain);
454 }
455
456 static void
457 delete_trace_variable_command (char *args, int from_tty)
458 {
459 int ix;
460 char **argv;
461 struct cleanup *back_to;
462
463 if (args == NULL)
464 {
465 if (query (_("Delete all trace state variables? ")))
466 VEC_free (tsv_s, tvariables);
467 dont_repeat ();
468 observer_notify_tsv_deleted (NULL);
469 return;
470 }
471
472 argv = gdb_buildargv (args);
473 back_to = make_cleanup_freeargv (argv);
474
475 for (ix = 0; argv[ix] != NULL; ix++)
476 {
477 if (*argv[ix] == '$')
478 delete_trace_state_variable (argv[ix] + 1);
479 else
480 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv[ix]);
481 }
482
483 do_cleanups (back_to);
484
485 dont_repeat ();
486 }
487
488 void
489 tvariables_info_1 (void)
490 {
491 struct trace_state_variable *tsv;
492 int ix;
493 int count = 0;
494 struct cleanup *back_to;
495 struct ui_out *uiout = current_uiout;
496
497 if (VEC_length (tsv_s, tvariables) == 0 && !ui_out_is_mi_like_p (uiout))
498 {
499 printf_filtered (_("No trace state variables.\n"));
500 return;
501 }
502
503 /* Try to acquire values from the target. */
504 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix, ++count)
505 tsv->value_known = target_get_trace_state_variable_value (tsv->number,
506 &(tsv->value));
507
508 back_to = make_cleanup_ui_out_table_begin_end (uiout, 3,
509 count, "trace-variables");
510 ui_out_table_header (uiout, 15, ui_left, "name", "Name");
511 ui_out_table_header (uiout, 11, ui_left, "initial", "Initial");
512 ui_out_table_header (uiout, 11, ui_left, "current", "Current");
513
514 ui_out_table_body (uiout);
515
516 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
517 {
518 struct cleanup *back_to2;
519 char *c;
520 char *name;
521
522 back_to2 = make_cleanup_ui_out_tuple_begin_end (uiout, "variable");
523
524 name = concat ("$", tsv->name, (char *) NULL);
525 make_cleanup (xfree, name);
526 ui_out_field_string (uiout, "name", name);
527 ui_out_field_string (uiout, "initial", plongest (tsv->initial_value));
528
529 if (tsv->value_known)
530 c = plongest (tsv->value);
531 else if (ui_out_is_mi_like_p (uiout))
532 /* For MI, we prefer not to use magic string constants, but rather
533 omit the field completely. The difference between unknown and
534 undefined does not seem important enough to represent. */
535 c = NULL;
536 else if (current_trace_status ()->running || traceframe_number >= 0)
537 /* The value is/was defined, but we don't have it. */
538 c = "<unknown>";
539 else
540 /* It is not meaningful to ask about the value. */
541 c = "<undefined>";
542 if (c)
543 ui_out_field_string (uiout, "current", c);
544 ui_out_text (uiout, "\n");
545
546 do_cleanups (back_to2);
547 }
548
549 do_cleanups (back_to);
550 }
551
552 /* List all the trace state variables. */
553
554 static void
555 tvariables_info (char *args, int from_tty)
556 {
557 tvariables_info_1 ();
558 }
559
560 /* Stash definitions of tsvs into the given file. */
561
562 void
563 save_trace_state_variables (struct ui_file *fp)
564 {
565 struct trace_state_variable *tsv;
566 int ix;
567
568 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
569 {
570 fprintf_unfiltered (fp, "tvariable $%s", tsv->name);
571 if (tsv->initial_value)
572 fprintf_unfiltered (fp, " = %s", plongest (tsv->initial_value));
573 fprintf_unfiltered (fp, "\n");
574 }
575 }
576
577 /* ACTIONS functions: */
578
579 /* The three functions:
580 collect_pseudocommand,
581 while_stepping_pseudocommand, and
582 end_actions_pseudocommand
583 are placeholders for "commands" that are actually ONLY to be used
584 within a tracepoint action list. If the actual function is ever called,
585 it means that somebody issued the "command" at the top level,
586 which is always an error. */
587
588 static void
589 end_actions_pseudocommand (char *args, int from_tty)
590 {
591 error (_("This command cannot be used at the top level."));
592 }
593
594 static void
595 while_stepping_pseudocommand (char *args, int from_tty)
596 {
597 error (_("This command can only be used in a tracepoint actions list."));
598 }
599
600 static void
601 collect_pseudocommand (char *args, int from_tty)
602 {
603 error (_("This command can only be used in a tracepoint actions list."));
604 }
605
606 static void
607 teval_pseudocommand (char *args, int from_tty)
608 {
609 error (_("This command can only be used in a tracepoint actions list."));
610 }
611
612 /* Parse any collection options, such as /s for strings. */
613
614 const char *
615 decode_agent_options (const char *exp)
616 {
617 struct value_print_options opts;
618
619 if (*exp != '/')
620 return exp;
621
622 /* Call this to borrow the print elements default for collection
623 size. */
624 get_user_print_options (&opts);
625
626 exp++;
627 if (*exp == 's')
628 {
629 if (target_supports_string_tracing ())
630 {
631 /* Allow an optional decimal number giving an explicit maximum
632 string length, defaulting it to the "print elements" value;
633 so "collect/s80 mystr" gets at most 80 bytes of string. */
634 trace_string_kludge = opts.print_max;
635 exp++;
636 if (*exp >= '0' && *exp <= '9')
637 trace_string_kludge = atoi (exp);
638 while (*exp >= '0' && *exp <= '9')
639 exp++;
640 }
641 else
642 error (_("Target does not support \"/s\" option for string tracing."));
643 }
644 else
645 error (_("Undefined collection format \"%c\"."), *exp);
646
647 exp = skip_spaces_const (exp);
648
649 return exp;
650 }
651
652 /* Enter a list of actions for a tracepoint. */
653 static void
654 trace_actions_command (char *args, int from_tty)
655 {
656 struct tracepoint *t;
657 struct command_line *l;
658
659 t = get_tracepoint_by_number (&args, NULL, 1);
660 if (t)
661 {
662 char *tmpbuf =
663 xstrprintf ("Enter actions for tracepoint %d, one per line.",
664 t->base.number);
665 struct cleanup *cleanups = make_cleanup (xfree, tmpbuf);
666
667 l = read_command_lines (tmpbuf, from_tty, 1,
668 check_tracepoint_command, t);
669 do_cleanups (cleanups);
670 breakpoint_set_commands (&t->base, l);
671 }
672 /* else just return */
673 }
674
675 /* Report the results of checking the agent expression, as errors or
676 internal errors. */
677
678 static void
679 report_agent_reqs_errors (struct agent_expr *aexpr)
680 {
681 /* All of the "flaws" are serious bytecode generation issues that
682 should never occur. */
683 if (aexpr->flaw != agent_flaw_none)
684 internal_error (__FILE__, __LINE__, _("expression is malformed"));
685
686 /* If analysis shows a stack underflow, GDB must have done something
687 badly wrong in its bytecode generation. */
688 if (aexpr->min_height < 0)
689 internal_error (__FILE__, __LINE__,
690 _("expression has min height < 0"));
691
692 /* Issue this error if the stack is predicted to get too deep. The
693 limit is rather arbitrary; a better scheme might be for the
694 target to report how much stack it will have available. The
695 depth roughly corresponds to parenthesization, so a limit of 20
696 amounts to 20 levels of expression nesting, which is actually
697 a pretty big hairy expression. */
698 if (aexpr->max_height > 20)
699 error (_("Expression is too complicated."));
700 }
701
702 /* worker function */
703 void
704 validate_actionline (const char *line, struct breakpoint *b)
705 {
706 struct cmd_list_element *c;
707 struct expression *exp = NULL;
708 struct cleanup *old_chain = NULL;
709 const char *tmp_p;
710 const char *p;
711 struct bp_location *loc;
712 struct agent_expr *aexpr;
713 struct tracepoint *t = (struct tracepoint *) b;
714
715 /* If EOF is typed, *line is NULL. */
716 if (line == NULL)
717 return;
718
719 p = skip_spaces_const (line);
720
721 /* Symbol lookup etc. */
722 if (*p == '\0') /* empty line: just prompt for another line. */
723 return;
724
725 if (*p == '#') /* comment line */
726 return;
727
728 c = lookup_cmd (&p, cmdlist, "", -1, 1);
729 if (c == 0)
730 error (_("`%s' is not a tracepoint action, or is ambiguous."), p);
731
732 if (cmd_cfunc_eq (c, collect_pseudocommand))
733 {
734 trace_string_kludge = 0;
735 if (*p == '/')
736 p = decode_agent_options (p);
737
738 do
739 { /* Repeat over a comma-separated list. */
740 QUIT; /* Allow user to bail out with ^C. */
741 p = skip_spaces_const (p);
742
743 if (*p == '$') /* Look for special pseudo-symbols. */
744 {
745 if (0 == strncasecmp ("reg", p + 1, 3)
746 || 0 == strncasecmp ("arg", p + 1, 3)
747 || 0 == strncasecmp ("loc", p + 1, 3)
748 || 0 == strncasecmp ("_ret", p + 1, 4)
749 || 0 == strncasecmp ("_sdata", p + 1, 6))
750 {
751 p = strchr (p, ',');
752 continue;
753 }
754 /* else fall thru, treat p as an expression and parse it! */
755 }
756 tmp_p = p;
757 for (loc = t->base.loc; loc; loc = loc->next)
758 {
759 p = tmp_p;
760 exp = parse_exp_1 (&p, loc->address,
761 block_for_pc (loc->address), 1);
762 old_chain = make_cleanup (free_current_contents, &exp);
763
764 if (exp->elts[0].opcode == OP_VAR_VALUE)
765 {
766 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
767 {
768 error (_("constant `%s' (value %s) "
769 "will not be collected."),
770 SYMBOL_PRINT_NAME (exp->elts[2].symbol),
771 plongest (SYMBOL_VALUE (exp->elts[2].symbol)));
772 }
773 else if (SYMBOL_CLASS (exp->elts[2].symbol)
774 == LOC_OPTIMIZED_OUT)
775 {
776 error (_("`%s' is optimized away "
777 "and cannot be collected."),
778 SYMBOL_PRINT_NAME (exp->elts[2].symbol));
779 }
780 }
781
782 /* We have something to collect, make sure that the expr to
783 bytecode translator can handle it and that it's not too
784 long. */
785 aexpr = gen_trace_for_expr (loc->address, exp);
786 make_cleanup_free_agent_expr (aexpr);
787
788 if (aexpr->len > MAX_AGENT_EXPR_LEN)
789 error (_("Expression is too complicated."));
790
791 ax_reqs (aexpr);
792
793 report_agent_reqs_errors (aexpr);
794
795 do_cleanups (old_chain);
796 }
797 }
798 while (p && *p++ == ',');
799 }
800
801 else if (cmd_cfunc_eq (c, teval_pseudocommand))
802 {
803 do
804 { /* Repeat over a comma-separated list. */
805 QUIT; /* Allow user to bail out with ^C. */
806 p = skip_spaces_const (p);
807
808 tmp_p = p;
809 for (loc = t->base.loc; loc; loc = loc->next)
810 {
811 p = tmp_p;
812
813 /* Only expressions are allowed for this action. */
814 exp = parse_exp_1 (&p, loc->address,
815 block_for_pc (loc->address), 1);
816 old_chain = make_cleanup (free_current_contents, &exp);
817
818 /* We have something to evaluate, make sure that the expr to
819 bytecode translator can handle it and that it's not too
820 long. */
821 aexpr = gen_eval_for_expr (loc->address, exp);
822 make_cleanup_free_agent_expr (aexpr);
823
824 if (aexpr->len > MAX_AGENT_EXPR_LEN)
825 error (_("Expression is too complicated."));
826
827 ax_reqs (aexpr);
828 report_agent_reqs_errors (aexpr);
829
830 do_cleanups (old_chain);
831 }
832 }
833 while (p && *p++ == ',');
834 }
835
836 else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
837 {
838 char *endp;
839
840 p = skip_spaces_const (p);
841 t->step_count = strtol (p, &endp, 0);
842 if (endp == p || t->step_count == 0)
843 error (_("while-stepping step count `%s' is malformed."), line);
844 p = endp;
845 }
846
847 else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
848 ;
849
850 else
851 error (_("`%s' is not a supported tracepoint action."), line);
852 }
853
854 enum {
855 memrange_absolute = -1
856 };
857
858 struct memrange
859 {
860 int type; /* memrange_absolute for absolute memory range,
861 else basereg number. */
862 bfd_signed_vma start;
863 bfd_signed_vma end;
864 };
865
866 struct collection_list
867 {
868 unsigned char regs_mask[32]; /* room for up to 256 regs */
869 long listsize;
870 long next_memrange;
871 struct memrange *list;
872 long aexpr_listsize; /* size of array pointed to by expr_list elt */
873 long next_aexpr_elt;
874 struct agent_expr **aexpr_list;
875
876 /* True is the user requested a collection of "$_sdata", "static
877 tracepoint data". */
878 int strace_data;
879 }
880 tracepoint_list, stepping_list;
881
882 /* MEMRANGE functions: */
883
884 static int memrange_cmp (const void *, const void *);
885
886 /* Compare memranges for qsort. */
887 static int
888 memrange_cmp (const void *va, const void *vb)
889 {
890 const struct memrange *a = va, *b = vb;
891
892 if (a->type < b->type)
893 return -1;
894 if (a->type > b->type)
895 return 1;
896 if (a->type == memrange_absolute)
897 {
898 if ((bfd_vma) a->start < (bfd_vma) b->start)
899 return -1;
900 if ((bfd_vma) a->start > (bfd_vma) b->start)
901 return 1;
902 }
903 else
904 {
905 if (a->start < b->start)
906 return -1;
907 if (a->start > b->start)
908 return 1;
909 }
910 return 0;
911 }
912
913 /* Sort the memrange list using qsort, and merge adjacent memranges. */
914 static void
915 memrange_sortmerge (struct collection_list *memranges)
916 {
917 int a, b;
918
919 qsort (memranges->list, memranges->next_memrange,
920 sizeof (struct memrange), memrange_cmp);
921 if (memranges->next_memrange > 0)
922 {
923 for (a = 0, b = 1; b < memranges->next_memrange; b++)
924 {
925 /* If memrange b overlaps or is adjacent to memrange a,
926 merge them. */
927 if (memranges->list[a].type == memranges->list[b].type
928 && memranges->list[b].start <= memranges->list[a].end)
929 {
930 if (memranges->list[b].end > memranges->list[a].end)
931 memranges->list[a].end = memranges->list[b].end;
932 continue; /* next b, same a */
933 }
934 a++; /* next a */
935 if (a != b)
936 memcpy (&memranges->list[a], &memranges->list[b],
937 sizeof (struct memrange));
938 }
939 memranges->next_memrange = a + 1;
940 }
941 }
942
943 /* Add a register to a collection list. */
944 static void
945 add_register (struct collection_list *collection, unsigned int regno)
946 {
947 if (info_verbose)
948 printf_filtered ("collect register %d\n", regno);
949 if (regno >= (8 * sizeof (collection->regs_mask)))
950 error (_("Internal: register number %d too large for tracepoint"),
951 regno);
952 collection->regs_mask[regno / 8] |= 1 << (regno % 8);
953 }
954
955 /* Add a memrange to a collection list. */
956 static void
957 add_memrange (struct collection_list *memranges,
958 int type, bfd_signed_vma base,
959 unsigned long len)
960 {
961 if (info_verbose)
962 {
963 printf_filtered ("(%d,", type);
964 printf_vma (base);
965 printf_filtered (",%ld)\n", len);
966 }
967
968 /* type: memrange_absolute == memory, other n == basereg */
969 memranges->list[memranges->next_memrange].type = type;
970 /* base: addr if memory, offset if reg relative. */
971 memranges->list[memranges->next_memrange].start = base;
972 /* len: we actually save end (base + len) for convenience */
973 memranges->list[memranges->next_memrange].end = base + len;
974 memranges->next_memrange++;
975 if (memranges->next_memrange >= memranges->listsize)
976 {
977 memranges->listsize *= 2;
978 memranges->list = xrealloc (memranges->list,
979 memranges->listsize);
980 }
981
982 if (type != memrange_absolute) /* Better collect the base register! */
983 add_register (memranges, type);
984 }
985
986 /* Add a symbol to a collection list. */
987 static void
988 collect_symbol (struct collection_list *collect,
989 struct symbol *sym,
990 struct gdbarch *gdbarch,
991 long frame_regno, long frame_offset,
992 CORE_ADDR scope)
993 {
994 unsigned long len;
995 unsigned int reg;
996 bfd_signed_vma offset;
997 int treat_as_expr = 0;
998
999 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
1000 switch (SYMBOL_CLASS (sym))
1001 {
1002 default:
1003 printf_filtered ("%s: don't know symbol class %d\n",
1004 SYMBOL_PRINT_NAME (sym),
1005 SYMBOL_CLASS (sym));
1006 break;
1007 case LOC_CONST:
1008 printf_filtered ("constant %s (value %s) will not be collected.\n",
1009 SYMBOL_PRINT_NAME (sym), plongest (SYMBOL_VALUE (sym)));
1010 break;
1011 case LOC_STATIC:
1012 offset = SYMBOL_VALUE_ADDRESS (sym);
1013 if (info_verbose)
1014 {
1015 char tmp[40];
1016
1017 sprintf_vma (tmp, offset);
1018 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1019 SYMBOL_PRINT_NAME (sym), len,
1020 tmp /* address */);
1021 }
1022 /* A struct may be a C++ class with static fields, go to general
1023 expression handling. */
1024 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
1025 treat_as_expr = 1;
1026 else
1027 add_memrange (collect, memrange_absolute, offset, len);
1028 break;
1029 case LOC_REGISTER:
1030 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
1031 if (info_verbose)
1032 printf_filtered ("LOC_REG[parm] %s: ",
1033 SYMBOL_PRINT_NAME (sym));
1034 add_register (collect, reg);
1035 /* Check for doubles stored in two registers. */
1036 /* FIXME: how about larger types stored in 3 or more regs? */
1037 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
1038 len > register_size (gdbarch, reg))
1039 add_register (collect, reg + 1);
1040 break;
1041 case LOC_REF_ARG:
1042 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1043 printf_filtered (" (will not collect %s)\n",
1044 SYMBOL_PRINT_NAME (sym));
1045 break;
1046 case LOC_ARG:
1047 reg = frame_regno;
1048 offset = frame_offset + SYMBOL_VALUE (sym);
1049 if (info_verbose)
1050 {
1051 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1052 SYMBOL_PRINT_NAME (sym), len);
1053 printf_vma (offset);
1054 printf_filtered (" from frame ptr reg %d\n", reg);
1055 }
1056 add_memrange (collect, reg, offset, len);
1057 break;
1058 case LOC_REGPARM_ADDR:
1059 reg = SYMBOL_VALUE (sym);
1060 offset = 0;
1061 if (info_verbose)
1062 {
1063 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1064 SYMBOL_PRINT_NAME (sym), len);
1065 printf_vma (offset);
1066 printf_filtered (" from reg %d\n", reg);
1067 }
1068 add_memrange (collect, reg, offset, len);
1069 break;
1070 case LOC_LOCAL:
1071 reg = frame_regno;
1072 offset = frame_offset + SYMBOL_VALUE (sym);
1073 if (info_verbose)
1074 {
1075 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1076 SYMBOL_PRINT_NAME (sym), len);
1077 printf_vma (offset);
1078 printf_filtered (" from frame ptr reg %d\n", reg);
1079 }
1080 add_memrange (collect, reg, offset, len);
1081 break;
1082
1083 case LOC_UNRESOLVED:
1084 treat_as_expr = 1;
1085 break;
1086
1087 case LOC_OPTIMIZED_OUT:
1088 printf_filtered ("%s has been optimized out of existence.\n",
1089 SYMBOL_PRINT_NAME (sym));
1090 break;
1091
1092 case LOC_COMPUTED:
1093 treat_as_expr = 1;
1094 break;
1095 }
1096
1097 /* Expressions are the most general case. */
1098 if (treat_as_expr)
1099 {
1100 struct agent_expr *aexpr;
1101 struct cleanup *old_chain1 = NULL;
1102
1103 aexpr = gen_trace_for_var (scope, gdbarch, sym);
1104
1105 /* It can happen that the symbol is recorded as a computed
1106 location, but it's been optimized away and doesn't actually
1107 have a location expression. */
1108 if (!aexpr)
1109 {
1110 printf_filtered ("%s has been optimized out of existence.\n",
1111 SYMBOL_PRINT_NAME (sym));
1112 return;
1113 }
1114
1115 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1116
1117 ax_reqs (aexpr);
1118
1119 report_agent_reqs_errors (aexpr);
1120
1121 discard_cleanups (old_chain1);
1122 add_aexpr (collect, aexpr);
1123
1124 /* Take care of the registers. */
1125 if (aexpr->reg_mask_len > 0)
1126 {
1127 int ndx1, ndx2;
1128
1129 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1130 {
1131 QUIT; /* Allow user to bail out with ^C. */
1132 if (aexpr->reg_mask[ndx1] != 0)
1133 {
1134 /* Assume chars have 8 bits. */
1135 for (ndx2 = 0; ndx2 < 8; ndx2++)
1136 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1137 /* It's used -- record it. */
1138 add_register (collect, ndx1 * 8 + ndx2);
1139 }
1140 }
1141 }
1142 }
1143 }
1144
1145 /* Data to be passed around in the calls to the locals and args
1146 iterators. */
1147
1148 struct add_local_symbols_data
1149 {
1150 struct collection_list *collect;
1151 struct gdbarch *gdbarch;
1152 CORE_ADDR pc;
1153 long frame_regno;
1154 long frame_offset;
1155 int count;
1156 };
1157
1158 /* The callback for the locals and args iterators. */
1159
1160 static void
1161 do_collect_symbol (const char *print_name,
1162 struct symbol *sym,
1163 void *cb_data)
1164 {
1165 struct add_local_symbols_data *p = cb_data;
1166
1167 collect_symbol (p->collect, sym, p->gdbarch, p->frame_regno,
1168 p->frame_offset, p->pc);
1169 p->count++;
1170 }
1171
1172 /* Add all locals (or args) symbols to collection list. */
1173 static void
1174 add_local_symbols (struct collection_list *collect,
1175 struct gdbarch *gdbarch, CORE_ADDR pc,
1176 long frame_regno, long frame_offset, int type)
1177 {
1178 struct block *block;
1179 struct add_local_symbols_data cb_data;
1180
1181 cb_data.collect = collect;
1182 cb_data.gdbarch = gdbarch;
1183 cb_data.pc = pc;
1184 cb_data.frame_regno = frame_regno;
1185 cb_data.frame_offset = frame_offset;
1186 cb_data.count = 0;
1187
1188 if (type == 'L')
1189 {
1190 block = block_for_pc (pc);
1191 if (block == NULL)
1192 {
1193 warning (_("Can't collect locals; "
1194 "no symbol table info available.\n"));
1195 return;
1196 }
1197
1198 iterate_over_block_local_vars (block, do_collect_symbol, &cb_data);
1199 if (cb_data.count == 0)
1200 warning (_("No locals found in scope."));
1201 }
1202 else
1203 {
1204 pc = get_pc_function_start (pc);
1205 block = block_for_pc (pc);
1206 if (block == NULL)
1207 {
1208 warning (_("Can't collect args; no symbol table info available."));
1209 return;
1210 }
1211
1212 iterate_over_block_arg_vars (block, do_collect_symbol, &cb_data);
1213 if (cb_data.count == 0)
1214 warning (_("No args found in scope."));
1215 }
1216 }
1217
1218 static void
1219 add_static_trace_data (struct collection_list *collection)
1220 {
1221 if (info_verbose)
1222 printf_filtered ("collect static trace data\n");
1223 collection->strace_data = 1;
1224 }
1225
1226 /* worker function */
1227 static void
1228 clear_collection_list (struct collection_list *list)
1229 {
1230 int ndx;
1231
1232 list->next_memrange = 0;
1233 for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1234 {
1235 free_agent_expr (list->aexpr_list[ndx]);
1236 list->aexpr_list[ndx] = NULL;
1237 }
1238 list->next_aexpr_elt = 0;
1239 memset (list->regs_mask, 0, sizeof (list->regs_mask));
1240 list->strace_data = 0;
1241 }
1242
1243 /* Reduce a collection list to string form (for gdb protocol). */
1244 static char **
1245 stringify_collection_list (struct collection_list *list, char *string)
1246 {
1247 char temp_buf[2048];
1248 char tmp2[40];
1249 int count;
1250 int ndx = 0;
1251 char *(*str_list)[];
1252 char *end;
1253 long i;
1254
1255 count = 1 + 1 + list->next_memrange + list->next_aexpr_elt + 1;
1256 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1257
1258 if (list->strace_data)
1259 {
1260 if (info_verbose)
1261 printf_filtered ("\nCollecting static trace data\n");
1262 end = temp_buf;
1263 *end++ = 'L';
1264 (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
1265 ndx++;
1266 }
1267
1268 for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1269 if (list->regs_mask[i] != 0) /* Skip leading zeroes in regs_mask. */
1270 break;
1271 if (list->regs_mask[i] != 0) /* Prepare to send regs_mask to the stub. */
1272 {
1273 if (info_verbose)
1274 printf_filtered ("\nCollecting registers (mask): 0x");
1275 end = temp_buf;
1276 *end++ = 'R';
1277 for (; i >= 0; i--)
1278 {
1279 QUIT; /* Allow user to bail out with ^C. */
1280 if (info_verbose)
1281 printf_filtered ("%02X", list->regs_mask[i]);
1282 sprintf (end, "%02X", list->regs_mask[i]);
1283 end += 2;
1284 }
1285 (*str_list)[ndx] = xstrdup (temp_buf);
1286 ndx++;
1287 }
1288 if (info_verbose)
1289 printf_filtered ("\n");
1290 if (list->next_memrange > 0 && info_verbose)
1291 printf_filtered ("Collecting memranges: \n");
1292 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1293 {
1294 QUIT; /* Allow user to bail out with ^C. */
1295 sprintf_vma (tmp2, list->list[i].start);
1296 if (info_verbose)
1297 {
1298 printf_filtered ("(%d, %s, %ld)\n",
1299 list->list[i].type,
1300 tmp2,
1301 (long) (list->list[i].end - list->list[i].start));
1302 }
1303 if (count + 27 > MAX_AGENT_EXPR_LEN)
1304 {
1305 (*str_list)[ndx] = savestring (temp_buf, count);
1306 ndx++;
1307 count = 0;
1308 end = temp_buf;
1309 }
1310
1311 {
1312 bfd_signed_vma length = list->list[i].end - list->list[i].start;
1313
1314 /* The "%X" conversion specifier expects an unsigned argument,
1315 so passing -1 (memrange_absolute) to it directly gives you
1316 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1317 Special-case it. */
1318 if (list->list[i].type == memrange_absolute)
1319 sprintf (end, "M-1,%s,%lX", tmp2, (long) length);
1320 else
1321 sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length);
1322 }
1323
1324 count += strlen (end);
1325 end = temp_buf + count;
1326 }
1327
1328 for (i = 0; i < list->next_aexpr_elt; i++)
1329 {
1330 QUIT; /* Allow user to bail out with ^C. */
1331 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1332 {
1333 (*str_list)[ndx] = savestring (temp_buf, count);
1334 ndx++;
1335 count = 0;
1336 end = temp_buf;
1337 }
1338 sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1339 end += 10; /* 'X' + 8 hex digits + ',' */
1340 count += 10;
1341
1342 end = mem2hex (list->aexpr_list[i]->buf,
1343 end, list->aexpr_list[i]->len);
1344 count += 2 * list->aexpr_list[i]->len;
1345 }
1346
1347 if (count != 0)
1348 {
1349 (*str_list)[ndx] = savestring (temp_buf, count);
1350 ndx++;
1351 count = 0;
1352 end = temp_buf;
1353 }
1354 (*str_list)[ndx] = NULL;
1355
1356 if (ndx == 0)
1357 {
1358 xfree (str_list);
1359 return NULL;
1360 }
1361 else
1362 return *str_list;
1363 }
1364
1365
1366 static void
1367 encode_actions_1 (struct command_line *action,
1368 struct breakpoint *t,
1369 struct bp_location *tloc,
1370 int frame_reg,
1371 LONGEST frame_offset,
1372 struct collection_list *collect,
1373 struct collection_list *stepping_list)
1374 {
1375 const char *action_exp;
1376 struct expression *exp = NULL;
1377 int i;
1378 struct value *tempval;
1379 struct cmd_list_element *cmd;
1380 struct agent_expr *aexpr;
1381
1382 for (; action; action = action->next)
1383 {
1384 QUIT; /* Allow user to bail out with ^C. */
1385 action_exp = action->line;
1386 action_exp = skip_spaces_const (action_exp);
1387
1388 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1389 if (cmd == 0)
1390 error (_("Bad action list item: %s"), action_exp);
1391
1392 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1393 {
1394 trace_string_kludge = 0;
1395 if (*action_exp == '/')
1396 action_exp = decode_agent_options (action_exp);
1397
1398 do
1399 { /* Repeat over a comma-separated list. */
1400 QUIT; /* Allow user to bail out with ^C. */
1401 action_exp = skip_spaces_const (action_exp);
1402
1403 if (0 == strncasecmp ("$reg", action_exp, 4))
1404 {
1405 for (i = 0; i < gdbarch_num_regs (tloc->gdbarch); i++)
1406 add_register (collect, i);
1407 action_exp = strchr (action_exp, ','); /* more? */
1408 }
1409 else if (0 == strncasecmp ("$arg", action_exp, 4))
1410 {
1411 add_local_symbols (collect,
1412 tloc->gdbarch,
1413 tloc->address,
1414 frame_reg,
1415 frame_offset,
1416 'A');
1417 action_exp = strchr (action_exp, ','); /* more? */
1418 }
1419 else if (0 == strncasecmp ("$loc", action_exp, 4))
1420 {
1421 add_local_symbols (collect,
1422 tloc->gdbarch,
1423 tloc->address,
1424 frame_reg,
1425 frame_offset,
1426 'L');
1427 action_exp = strchr (action_exp, ','); /* more? */
1428 }
1429 else if (0 == strncasecmp ("$_ret", action_exp, 5))
1430 {
1431 struct cleanup *old_chain1 = NULL;
1432
1433 aexpr = gen_trace_for_return_address (tloc->address,
1434 tloc->gdbarch);
1435
1436 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1437
1438 ax_reqs (aexpr);
1439 report_agent_reqs_errors (aexpr);
1440
1441 discard_cleanups (old_chain1);
1442 add_aexpr (collect, aexpr);
1443
1444 /* take care of the registers */
1445 if (aexpr->reg_mask_len > 0)
1446 {
1447 int ndx1, ndx2;
1448
1449 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1450 {
1451 QUIT; /* allow user to bail out with ^C */
1452 if (aexpr->reg_mask[ndx1] != 0)
1453 {
1454 /* assume chars have 8 bits */
1455 for (ndx2 = 0; ndx2 < 8; ndx2++)
1456 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1457 /* it's used -- record it */
1458 add_register (collect,
1459 ndx1 * 8 + ndx2);
1460 }
1461 }
1462 }
1463
1464 action_exp = strchr (action_exp, ','); /* more? */
1465 }
1466 else if (0 == strncasecmp ("$_sdata", action_exp, 7))
1467 {
1468 add_static_trace_data (collect);
1469 action_exp = strchr (action_exp, ','); /* more? */
1470 }
1471 else
1472 {
1473 unsigned long addr;
1474 struct cleanup *old_chain = NULL;
1475 struct cleanup *old_chain1 = NULL;
1476
1477 exp = parse_exp_1 (&action_exp, tloc->address,
1478 block_for_pc (tloc->address), 1);
1479 old_chain = make_cleanup (free_current_contents, &exp);
1480
1481 switch (exp->elts[0].opcode)
1482 {
1483 case OP_REGISTER:
1484 {
1485 const char *name = &exp->elts[2].string;
1486
1487 i = user_reg_map_name_to_regnum (tloc->gdbarch,
1488 name, strlen (name));
1489 if (i == -1)
1490 internal_error (__FILE__, __LINE__,
1491 _("Register $%s not available"),
1492 name);
1493 if (info_verbose)
1494 printf_filtered ("OP_REGISTER: ");
1495 add_register (collect, i);
1496 break;
1497 }
1498
1499 case UNOP_MEMVAL:
1500 /* Safe because we know it's a simple expression. */
1501 tempval = evaluate_expression (exp);
1502 addr = value_address (tempval);
1503 /* Initialize the TYPE_LENGTH if it is a typedef. */
1504 check_typedef (exp->elts[1].type);
1505 add_memrange (collect, memrange_absolute, addr,
1506 TYPE_LENGTH (exp->elts[1].type));
1507 break;
1508
1509 case OP_VAR_VALUE:
1510 collect_symbol (collect,
1511 exp->elts[2].symbol,
1512 tloc->gdbarch,
1513 frame_reg,
1514 frame_offset,
1515 tloc->address);
1516 break;
1517
1518 default: /* Full-fledged expression. */
1519 aexpr = gen_trace_for_expr (tloc->address, exp);
1520
1521 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1522
1523 ax_reqs (aexpr);
1524
1525 report_agent_reqs_errors (aexpr);
1526
1527 discard_cleanups (old_chain1);
1528 add_aexpr (collect, aexpr);
1529
1530 /* Take care of the registers. */
1531 if (aexpr->reg_mask_len > 0)
1532 {
1533 int ndx1;
1534 int ndx2;
1535
1536 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1537 {
1538 QUIT; /* Allow user to bail out with ^C. */
1539 if (aexpr->reg_mask[ndx1] != 0)
1540 {
1541 /* Assume chars have 8 bits. */
1542 for (ndx2 = 0; ndx2 < 8; ndx2++)
1543 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1544 /* It's used -- record it. */
1545 add_register (collect,
1546 ndx1 * 8 + ndx2);
1547 }
1548 }
1549 }
1550 break;
1551 } /* switch */
1552 do_cleanups (old_chain);
1553 } /* do */
1554 }
1555 while (action_exp && *action_exp++ == ',');
1556 } /* if */
1557 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1558 {
1559 do
1560 { /* Repeat over a comma-separated list. */
1561 QUIT; /* Allow user to bail out with ^C. */
1562 action_exp = skip_spaces_const (action_exp);
1563
1564 {
1565 struct cleanup *old_chain = NULL;
1566 struct cleanup *old_chain1 = NULL;
1567
1568 exp = parse_exp_1 (&action_exp, tloc->address,
1569 block_for_pc (tloc->address), 1);
1570 old_chain = make_cleanup (free_current_contents, &exp);
1571
1572 aexpr = gen_eval_for_expr (tloc->address, exp);
1573 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1574
1575 ax_reqs (aexpr);
1576 report_agent_reqs_errors (aexpr);
1577
1578 discard_cleanups (old_chain1);
1579 /* Even though we're not officially collecting, add
1580 to the collect list anyway. */
1581 add_aexpr (collect, aexpr);
1582
1583 do_cleanups (old_chain);
1584 } /* do */
1585 }
1586 while (action_exp && *action_exp++ == ',');
1587 } /* if */
1588 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1589 {
1590 /* We check against nested while-stepping when setting
1591 breakpoint action, so no way to run into nested
1592 here. */
1593 gdb_assert (stepping_list);
1594
1595 encode_actions_1 (action->body_list[0], t, tloc, frame_reg,
1596 frame_offset, stepping_list, NULL);
1597 }
1598 else
1599 error (_("Invalid tracepoint command '%s'"), action->line);
1600 } /* for */
1601 }
1602
1603 /* Render all actions into gdb protocol. */
1604
1605 void
1606 encode_actions (struct breakpoint *t, struct bp_location *tloc,
1607 char ***tdp_actions, char ***stepping_actions)
1608 {
1609 static char tdp_buff[2048], step_buff[2048];
1610 char *default_collect_line = NULL;
1611 struct command_line *actions;
1612 struct command_line *default_collect_action = NULL;
1613 int frame_reg;
1614 LONGEST frame_offset;
1615 struct cleanup *back_to;
1616
1617 back_to = make_cleanup (null_cleanup, NULL);
1618
1619 clear_collection_list (&tracepoint_list);
1620 clear_collection_list (&stepping_list);
1621
1622 *tdp_actions = NULL;
1623 *stepping_actions = NULL;
1624
1625 gdbarch_virtual_frame_pointer (tloc->gdbarch,
1626 tloc->address, &frame_reg, &frame_offset);
1627
1628 actions = breakpoint_commands (t);
1629
1630 /* If there are default expressions to collect, make up a collect
1631 action and prepend to the action list to encode. Note that since
1632 validation is per-tracepoint (local var "xyz" might be valid for
1633 one tracepoint and not another, etc), we make up the action on
1634 the fly, and don't cache it. */
1635 if (*default_collect)
1636 {
1637 default_collect_line = xstrprintf ("collect %s", default_collect);
1638 make_cleanup (xfree, default_collect_line);
1639
1640 validate_actionline (default_collect_line, t);
1641
1642 default_collect_action = xmalloc (sizeof (struct command_line));
1643 make_cleanup (xfree, default_collect_action);
1644 default_collect_action->next = actions;
1645 default_collect_action->line = default_collect_line;
1646 actions = default_collect_action;
1647 }
1648 encode_actions_1 (actions, t, tloc, frame_reg, frame_offset,
1649 &tracepoint_list, &stepping_list);
1650
1651 memrange_sortmerge (&tracepoint_list);
1652 memrange_sortmerge (&stepping_list);
1653
1654 *tdp_actions = stringify_collection_list (&tracepoint_list,
1655 tdp_buff);
1656 *stepping_actions = stringify_collection_list (&stepping_list,
1657 step_buff);
1658
1659 do_cleanups (back_to);
1660 }
1661
1662 static void
1663 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
1664 {
1665 if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1666 {
1667 collect->aexpr_list =
1668 xrealloc (collect->aexpr_list,
1669 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
1670 collect->aexpr_listsize *= 2;
1671 }
1672 collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1673 collect->next_aexpr_elt++;
1674 }
1675
1676 static void
1677 process_tracepoint_on_disconnect (void)
1678 {
1679 VEC(breakpoint_p) *tp_vec = NULL;
1680 int ix;
1681 struct breakpoint *b;
1682 int has_pending_p = 0;
1683
1684 /* Check whether we still have pending tracepoint. If we have, warn the
1685 user that pending tracepoint will no longer work. */
1686 tp_vec = all_tracepoints ();
1687 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1688 {
1689 if (b->loc == NULL)
1690 {
1691 has_pending_p = 1;
1692 break;
1693 }
1694 else
1695 {
1696 struct bp_location *loc1;
1697
1698 for (loc1 = b->loc; loc1; loc1 = loc1->next)
1699 {
1700 if (loc1->shlib_disabled)
1701 {
1702 has_pending_p = 1;
1703 break;
1704 }
1705 }
1706
1707 if (has_pending_p)
1708 break;
1709 }
1710 }
1711 VEC_free (breakpoint_p, tp_vec);
1712
1713 if (has_pending_p)
1714 warning (_("Pending tracepoints will not be resolved while"
1715 " GDB is disconnected\n"));
1716 }
1717
1718
1719 void
1720 start_tracing (char *notes)
1721 {
1722 VEC(breakpoint_p) *tp_vec = NULL;
1723 int ix;
1724 struct breakpoint *b;
1725 struct trace_state_variable *tsv;
1726 int any_enabled = 0, num_to_download = 0;
1727 int ret;
1728
1729 tp_vec = all_tracepoints ();
1730
1731 /* No point in tracing without any tracepoints... */
1732 if (VEC_length (breakpoint_p, tp_vec) == 0)
1733 {
1734 VEC_free (breakpoint_p, tp_vec);
1735 error (_("No tracepoints defined, not starting trace"));
1736 }
1737
1738 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1739 {
1740 struct tracepoint *t = (struct tracepoint *) b;
1741 struct bp_location *loc;
1742
1743 if (b->enable_state == bp_enabled)
1744 any_enabled = 1;
1745
1746 if ((b->type == bp_fast_tracepoint
1747 ? may_insert_fast_tracepoints
1748 : may_insert_tracepoints))
1749 ++num_to_download;
1750 else
1751 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1752 (b->type == bp_fast_tracepoint ? "fast " : ""), b->number);
1753 }
1754
1755 if (!any_enabled)
1756 {
1757 if (target_supports_enable_disable_tracepoint ())
1758 warning (_("No tracepoints enabled"));
1759 else
1760 {
1761 /* No point in tracing with only disabled tracepoints that
1762 cannot be re-enabled. */
1763 VEC_free (breakpoint_p, tp_vec);
1764 error (_("No tracepoints enabled, not starting trace"));
1765 }
1766 }
1767
1768 if (num_to_download <= 0)
1769 {
1770 VEC_free (breakpoint_p, tp_vec);
1771 error (_("No tracepoints that may be downloaded, not starting trace"));
1772 }
1773
1774 target_trace_init ();
1775
1776 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1777 {
1778 struct tracepoint *t = (struct tracepoint *) b;
1779 struct bp_location *loc;
1780 int bp_location_downloaded = 0;
1781
1782 /* Clear `inserted' flag. */
1783 for (loc = b->loc; loc; loc = loc->next)
1784 loc->inserted = 0;
1785
1786 if ((b->type == bp_fast_tracepoint
1787 ? !may_insert_fast_tracepoints
1788 : !may_insert_tracepoints))
1789 continue;
1790
1791 t->number_on_target = 0;
1792
1793 for (loc = b->loc; loc; loc = loc->next)
1794 {
1795 /* Since tracepoint locations are never duplicated, `inserted'
1796 flag should be zero. */
1797 gdb_assert (!loc->inserted);
1798
1799 target_download_tracepoint (loc);
1800
1801 loc->inserted = 1;
1802 bp_location_downloaded = 1;
1803 }
1804
1805 t->number_on_target = b->number;
1806
1807 for (loc = b->loc; loc; loc = loc->next)
1808 if (loc->probe != NULL)
1809 loc->probe->pops->set_semaphore (loc->probe, loc->gdbarch);
1810
1811 if (bp_location_downloaded)
1812 observer_notify_breakpoint_modified (b);
1813 }
1814 VEC_free (breakpoint_p, tp_vec);
1815
1816 /* Send down all the trace state variables too. */
1817 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1818 {
1819 target_download_trace_state_variable (tsv);
1820 }
1821
1822 /* Tell target to treat text-like sections as transparent. */
1823 target_trace_set_readonly_regions ();
1824 /* Set some mode flags. */
1825 target_set_disconnected_tracing (disconnected_tracing);
1826 target_set_circular_trace_buffer (circular_trace_buffer);
1827 target_set_trace_buffer_size (trace_buffer_size);
1828
1829 if (!notes)
1830 notes = trace_notes;
1831 ret = target_set_trace_notes (trace_user, notes, NULL);
1832
1833 if (!ret && (trace_user || notes))
1834 warning (_("Target does not support trace user/notes, info ignored"));
1835
1836 /* Now insert traps and begin collecting data. */
1837 target_trace_start ();
1838
1839 /* Reset our local state. */
1840 set_traceframe_num (-1);
1841 set_tracepoint_num (-1);
1842 set_traceframe_context (NULL);
1843 current_trace_status()->running = 1;
1844 clear_traceframe_info ();
1845 }
1846
1847 /* The tstart command requests the target to start a new trace run.
1848 The command passes any arguments it has to the target verbatim, as
1849 an optional "trace note". This is useful as for instance a warning
1850 to other users if the trace runs disconnected, and you don't want
1851 anybody else messing with the target. */
1852
1853 static void
1854 trace_start_command (char *args, int from_tty)
1855 {
1856 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1857
1858 if (current_trace_status ()->running)
1859 {
1860 if (from_tty
1861 && !query (_("A trace is running already. Start a new run? ")))
1862 error (_("New trace run not started."));
1863 }
1864
1865 start_tracing (args);
1866 }
1867
1868 /* The tstop command stops the tracing run. The command passes any
1869 supplied arguments to the target verbatim as a "stop note"; if the
1870 target supports trace notes, then it will be reported back as part
1871 of the trace run's status. */
1872
1873 static void
1874 trace_stop_command (char *args, int from_tty)
1875 {
1876 if (!current_trace_status ()->running)
1877 error (_("Trace is not running."));
1878
1879 stop_tracing (args);
1880 }
1881
1882 void
1883 stop_tracing (char *note)
1884 {
1885 int ret;
1886 VEC(breakpoint_p) *tp_vec = NULL;
1887 int ix;
1888 struct breakpoint *t;
1889
1890 target_trace_stop ();
1891
1892 tp_vec = all_tracepoints ();
1893 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1894 {
1895 struct bp_location *loc;
1896
1897 if ((t->type == bp_fast_tracepoint
1898 ? !may_insert_fast_tracepoints
1899 : !may_insert_tracepoints))
1900 continue;
1901
1902 for (loc = t->loc; loc; loc = loc->next)
1903 {
1904 /* GDB can be totally absent in some disconnected trace scenarios,
1905 but we don't really care if this semaphore goes out of sync.
1906 That's why we are decrementing it here, but not taking care
1907 in other places. */
1908 if (loc->probe != NULL)
1909 loc->probe->pops->clear_semaphore (loc->probe, loc->gdbarch);
1910 }
1911 }
1912
1913 VEC_free (breakpoint_p, tp_vec);
1914
1915 if (!note)
1916 note = trace_stop_notes;
1917 ret = target_set_trace_notes (NULL, NULL, note);
1918
1919 if (!ret && note)
1920 warning (_("Target does not support trace notes, note ignored"));
1921
1922 /* Should change in response to reply? */
1923 current_trace_status ()->running = 0;
1924 }
1925
1926 /* tstatus command */
1927 static void
1928 trace_status_command (char *args, int from_tty)
1929 {
1930 struct trace_status *ts = current_trace_status ();
1931 int status, ix;
1932 VEC(breakpoint_p) *tp_vec = NULL;
1933 struct breakpoint *t;
1934
1935 status = target_get_trace_status (ts);
1936
1937 if (status == -1)
1938 {
1939 if (ts->filename != NULL)
1940 printf_filtered (_("Using a trace file.\n"));
1941 else
1942 {
1943 printf_filtered (_("Trace can not be run on this target.\n"));
1944 return;
1945 }
1946 }
1947
1948 if (!ts->running_known)
1949 {
1950 printf_filtered (_("Run/stop status is unknown.\n"));
1951 }
1952 else if (ts->running)
1953 {
1954 printf_filtered (_("Trace is running on the target.\n"));
1955 }
1956 else
1957 {
1958 switch (ts->stop_reason)
1959 {
1960 case trace_never_run:
1961 printf_filtered (_("No trace has been run on the target.\n"));
1962 break;
1963 case tstop_command:
1964 if (ts->stop_desc)
1965 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1966 ts->stop_desc);
1967 else
1968 printf_filtered (_("Trace stopped by a tstop command.\n"));
1969 break;
1970 case trace_buffer_full:
1971 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1972 break;
1973 case trace_disconnected:
1974 printf_filtered (_("Trace stopped because of disconnection.\n"));
1975 break;
1976 case tracepoint_passcount:
1977 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1978 ts->stopping_tracepoint);
1979 break;
1980 case tracepoint_error:
1981 if (ts->stopping_tracepoint)
1982 printf_filtered (_("Trace stopped by an "
1983 "error (%s, tracepoint %d).\n"),
1984 ts->stop_desc, ts->stopping_tracepoint);
1985 else
1986 printf_filtered (_("Trace stopped by an error (%s).\n"),
1987 ts->stop_desc);
1988 break;
1989 case trace_stop_reason_unknown:
1990 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1991 break;
1992 default:
1993 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1994 ts->stop_reason);
1995 break;
1996 }
1997 }
1998
1999 if (ts->traceframes_created >= 0
2000 && ts->traceframe_count != ts->traceframes_created)
2001 {
2002 printf_filtered (_("Buffer contains %d trace "
2003 "frames (of %d created total).\n"),
2004 ts->traceframe_count, ts->traceframes_created);
2005 }
2006 else if (ts->traceframe_count >= 0)
2007 {
2008 printf_filtered (_("Collected %d trace frames.\n"),
2009 ts->traceframe_count);
2010 }
2011
2012 if (ts->buffer_free >= 0)
2013 {
2014 if (ts->buffer_size >= 0)
2015 {
2016 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2017 ts->buffer_free, ts->buffer_size);
2018 if (ts->buffer_size > 0)
2019 printf_filtered (_(" (%d%% full)"),
2020 ((int) ((((long long) (ts->buffer_size
2021 - ts->buffer_free)) * 100)
2022 / ts->buffer_size)));
2023 printf_filtered (_(".\n"));
2024 }
2025 else
2026 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2027 ts->buffer_free);
2028 }
2029
2030 if (ts->disconnected_tracing)
2031 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2032 else
2033 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2034
2035 if (ts->circular_buffer)
2036 printf_filtered (_("Trace buffer is circular.\n"));
2037
2038 if (ts->user_name && strlen (ts->user_name) > 0)
2039 printf_filtered (_("Trace user is %s.\n"), ts->user_name);
2040
2041 if (ts->notes && strlen (ts->notes) > 0)
2042 printf_filtered (_("Trace notes: %s.\n"), ts->notes);
2043
2044 /* Now report on what we're doing with tfind. */
2045 if (traceframe_number >= 0)
2046 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2047 traceframe_number, tracepoint_number);
2048 else
2049 printf_filtered (_("Not looking at any trace frame.\n"));
2050
2051 /* Report start/stop times if supplied. */
2052 if (ts->start_time)
2053 {
2054 if (ts->stop_time)
2055 {
2056 LONGEST run_time = ts->stop_time - ts->start_time;
2057
2058 /* Reporting a run time is more readable than two long numbers. */
2059 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2060 (long int) ts->start_time / 1000000,
2061 (long int) ts->start_time % 1000000,
2062 (long int) run_time / 1000000,
2063 (long int) run_time % 1000000);
2064 }
2065 else
2066 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2067 (long int) ts->start_time / 1000000,
2068 (long int) ts->start_time % 1000000);
2069 }
2070 else if (ts->stop_time)
2071 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2072 (long int) ts->stop_time / 1000000,
2073 (long int) ts->stop_time % 1000000);
2074
2075 /* Now report any per-tracepoint status available. */
2076 tp_vec = all_tracepoints ();
2077
2078 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
2079 target_get_tracepoint_status (t, NULL);
2080
2081 VEC_free (breakpoint_p, tp_vec);
2082 }
2083
2084 /* Report the trace status to uiout, in a way suitable for MI, and not
2085 suitable for CLI. If ON_STOP is true, suppress a few fields that
2086 are not meaningful in the -trace-stop response.
2087
2088 The implementation is essentially parallel to trace_status_command, but
2089 merging them will result in unreadable code. */
2090 void
2091 trace_status_mi (int on_stop)
2092 {
2093 struct ui_out *uiout = current_uiout;
2094 struct trace_status *ts = current_trace_status ();
2095 int status;
2096
2097 status = target_get_trace_status (ts);
2098
2099 if (status == -1 && ts->filename == NULL)
2100 {
2101 ui_out_field_string (uiout, "supported", "0");
2102 return;
2103 }
2104
2105 if (ts->filename != NULL)
2106 ui_out_field_string (uiout, "supported", "file");
2107 else if (!on_stop)
2108 ui_out_field_string (uiout, "supported", "1");
2109
2110 if (ts->filename != NULL)
2111 ui_out_field_string (uiout, "trace-file", ts->filename);
2112
2113 gdb_assert (ts->running_known);
2114
2115 if (ts->running)
2116 {
2117 ui_out_field_string (uiout, "running", "1");
2118
2119 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2120 Given that the frontend gets the status either on -trace-stop, or from
2121 -trace-status after re-connection, it does not seem like this
2122 information is necessary for anything. It is not necessary for either
2123 figuring the vital state of the target nor for navigation of trace
2124 frames. If the frontend wants to show the current state is some
2125 configure dialog, it can request the value when such dialog is
2126 invoked by the user. */
2127 }
2128 else
2129 {
2130 char *stop_reason = NULL;
2131 int stopping_tracepoint = -1;
2132
2133 if (!on_stop)
2134 ui_out_field_string (uiout, "running", "0");
2135
2136 if (ts->stop_reason != trace_stop_reason_unknown)
2137 {
2138 switch (ts->stop_reason)
2139 {
2140 case tstop_command:
2141 stop_reason = "request";
2142 break;
2143 case trace_buffer_full:
2144 stop_reason = "overflow";
2145 break;
2146 case trace_disconnected:
2147 stop_reason = "disconnection";
2148 break;
2149 case tracepoint_passcount:
2150 stop_reason = "passcount";
2151 stopping_tracepoint = ts->stopping_tracepoint;
2152 break;
2153 case tracepoint_error:
2154 stop_reason = "error";
2155 stopping_tracepoint = ts->stopping_tracepoint;
2156 break;
2157 }
2158
2159 if (stop_reason)
2160 {
2161 ui_out_field_string (uiout, "stop-reason", stop_reason);
2162 if (stopping_tracepoint != -1)
2163 ui_out_field_int (uiout, "stopping-tracepoint",
2164 stopping_tracepoint);
2165 if (ts->stop_reason == tracepoint_error)
2166 ui_out_field_string (uiout, "error-description",
2167 ts->stop_desc);
2168 }
2169 }
2170 }
2171
2172 if (ts->traceframe_count != -1)
2173 ui_out_field_int (uiout, "frames", ts->traceframe_count);
2174 if (ts->traceframes_created != -1)
2175 ui_out_field_int (uiout, "frames-created", ts->traceframes_created);
2176 if (ts->buffer_size != -1)
2177 ui_out_field_int (uiout, "buffer-size", ts->buffer_size);
2178 if (ts->buffer_free != -1)
2179 ui_out_field_int (uiout, "buffer-free", ts->buffer_free);
2180
2181 ui_out_field_int (uiout, "disconnected", ts->disconnected_tracing);
2182 ui_out_field_int (uiout, "circular", ts->circular_buffer);
2183
2184 ui_out_field_string (uiout, "user-name", ts->user_name);
2185 ui_out_field_string (uiout, "notes", ts->notes);
2186
2187 {
2188 char buf[100];
2189
2190 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2191 (long int) ts->start_time / 1000000,
2192 (long int) ts->start_time % 1000000);
2193 ui_out_field_string (uiout, "start-time", buf);
2194 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2195 (long int) ts->stop_time / 1000000,
2196 (long int) ts->stop_time % 1000000);
2197 ui_out_field_string (uiout, "stop-time", buf);
2198 }
2199 }
2200
2201 /* This function handles the details of what to do about an ongoing
2202 tracing run if the user has asked to detach or otherwise disconnect
2203 from the target. */
2204 void
2205 disconnect_tracing (int from_tty)
2206 {
2207 /* It can happen that the target that was tracing went away on its
2208 own, and we didn't notice. Get a status update, and if the
2209 current target doesn't even do tracing, then assume it's not
2210 running anymore. */
2211 if (target_get_trace_status (current_trace_status ()) < 0)
2212 current_trace_status ()->running = 0;
2213
2214 /* If running interactively, give the user the option to cancel and
2215 then decide what to do differently with the run. Scripts are
2216 just going to disconnect and let the target deal with it,
2217 according to how it's been instructed previously via
2218 disconnected-tracing. */
2219 if (current_trace_status ()->running && from_tty)
2220 {
2221 process_tracepoint_on_disconnect ();
2222
2223 if (current_trace_status ()->disconnected_tracing)
2224 {
2225 if (!query (_("Trace is running and will "
2226 "continue after detach; detach anyway? ")))
2227 error (_("Not confirmed."));
2228 }
2229 else
2230 {
2231 if (!query (_("Trace is running but will "
2232 "stop on detach; detach anyway? ")))
2233 error (_("Not confirmed."));
2234 }
2235 }
2236
2237 /* Also we want to be out of tfind mode, otherwise things can get
2238 confusing upon reconnection. Just use these calls instead of
2239 full tfind_1 behavior because we're in the middle of detaching,
2240 and there's no point to updating current stack frame etc. */
2241 set_current_traceframe (-1);
2242 set_tracepoint_num (-1);
2243 set_traceframe_context (NULL);
2244 }
2245
2246 /* Worker function for the various flavors of the tfind command. */
2247 void
2248 tfind_1 (enum trace_find_type type, int num,
2249 ULONGEST addr1, ULONGEST addr2,
2250 int from_tty)
2251 {
2252 int target_frameno = -1, target_tracept = -1;
2253 struct frame_id old_frame_id = null_frame_id;
2254 struct tracepoint *tp;
2255 struct ui_out *uiout = current_uiout;
2256
2257 /* Only try to get the current stack frame if we have a chance of
2258 succeeding. In particular, if we're trying to get a first trace
2259 frame while all threads are running, it's not going to succeed,
2260 so leave it with a default value and let the frame comparison
2261 below (correctly) decide to print out the source location of the
2262 trace frame. */
2263 if (!(type == tfind_number && num == -1)
2264 && (has_stack_frames () || traceframe_number >= 0))
2265 old_frame_id = get_frame_id (get_current_frame ());
2266
2267 target_frameno = target_trace_find (type, num, addr1, addr2,
2268 &target_tracept);
2269
2270 if (type == tfind_number
2271 && num == -1
2272 && target_frameno == -1)
2273 {
2274 /* We told the target to get out of tfind mode, and it did. */
2275 }
2276 else if (target_frameno == -1)
2277 {
2278 /* A request for a non-existent trace frame has failed.
2279 Our response will be different, depending on FROM_TTY:
2280
2281 If FROM_TTY is true, meaning that this command was
2282 typed interactively by the user, then give an error
2283 and DO NOT change the state of traceframe_number etc.
2284
2285 However if FROM_TTY is false, meaning that we're either
2286 in a script, a loop, or a user-defined command, then
2287 DON'T give an error, but DO change the state of
2288 traceframe_number etc. to invalid.
2289
2290 The rationalle is that if you typed the command, you
2291 might just have committed a typo or something, and you'd
2292 like to NOT lose your current debugging state. However
2293 if you're in a user-defined command or especially in a
2294 loop, then you need a way to detect that the command
2295 failed WITHOUT aborting. This allows you to write
2296 scripts that search thru the trace buffer until the end,
2297 and then continue on to do something else. */
2298
2299 if (from_tty)
2300 error (_("Target failed to find requested trace frame."));
2301 else
2302 {
2303 if (info_verbose)
2304 printf_filtered ("End of trace buffer.\n");
2305 #if 0 /* dubious now? */
2306 /* The following will not recurse, since it's
2307 special-cased. */
2308 trace_find_command ("-1", from_tty);
2309 #endif
2310 }
2311 }
2312
2313 tp = get_tracepoint_by_number_on_target (target_tracept);
2314
2315 reinit_frame_cache ();
2316 target_dcache_invalidate ();
2317
2318 set_tracepoint_num (tp ? tp->base.number : target_tracept);
2319
2320 if (target_frameno != get_traceframe_number ())
2321 observer_notify_traceframe_changed (target_frameno, tracepoint_number);
2322
2323 set_current_traceframe (target_frameno);
2324
2325 if (target_frameno == -1)
2326 set_traceframe_context (NULL);
2327 else
2328 set_traceframe_context (get_current_frame ());
2329
2330 if (traceframe_number >= 0)
2331 {
2332 /* Use different branches for MI and CLI to make CLI messages
2333 i18n-eable. */
2334 if (ui_out_is_mi_like_p (uiout))
2335 {
2336 ui_out_field_string (uiout, "found", "1");
2337 ui_out_field_int (uiout, "tracepoint", tracepoint_number);
2338 ui_out_field_int (uiout, "traceframe", traceframe_number);
2339 }
2340 else
2341 {
2342 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2343 traceframe_number, tracepoint_number);
2344 }
2345 }
2346 else
2347 {
2348 if (ui_out_is_mi_like_p (uiout))
2349 ui_out_field_string (uiout, "found", "0");
2350 else if (type == tfind_number && num == -1)
2351 printf_unfiltered (_("No longer looking at any trace frame\n"));
2352 else /* This case may never occur, check. */
2353 printf_unfiltered (_("No trace frame found\n"));
2354 }
2355
2356 /* If we're in nonstop mode and getting out of looking at trace
2357 frames, there won't be any current frame to go back to and
2358 display. */
2359 if (from_tty
2360 && (has_stack_frames () || traceframe_number >= 0))
2361 {
2362 enum print_what print_what;
2363
2364 /* NOTE: in imitation of the step command, try to determine
2365 whether we have made a transition from one function to
2366 another. If so, we'll print the "stack frame" (ie. the new
2367 function and it's arguments) -- otherwise we'll just show the
2368 new source line. */
2369
2370 if (frame_id_eq (old_frame_id,
2371 get_frame_id (get_current_frame ())))
2372 print_what = SRC_LINE;
2373 else
2374 print_what = SRC_AND_LOC;
2375
2376 print_stack_frame (get_selected_frame (NULL), 1, print_what);
2377 do_displays ();
2378 }
2379 }
2380
2381 /* trace_find_command takes a trace frame number n,
2382 sends "QTFrame:<n>" to the target,
2383 and accepts a reply that may contain several optional pieces
2384 of information: a frame number, a tracepoint number, and an
2385 indication of whether this is a trap frame or a stepping frame.
2386
2387 The minimal response is just "OK" (which indicates that the
2388 target does not give us a frame number or a tracepoint number).
2389 Instead of that, the target may send us a string containing
2390 any combination of:
2391 F<hexnum> (gives the selected frame number)
2392 T<hexnum> (gives the selected tracepoint number)
2393 */
2394
2395 /* tfind command */
2396 static void
2397 trace_find_command (char *args, int from_tty)
2398 { /* This should only be called with a numeric argument. */
2399 int frameno = -1;
2400
2401 if (current_trace_status ()->running
2402 && current_trace_status ()->filename == NULL)
2403 error (_("May not look at trace frames while trace is running."));
2404
2405 if (args == 0 || *args == 0)
2406 { /* TFIND with no args means find NEXT trace frame. */
2407 if (traceframe_number == -1)
2408 frameno = 0; /* "next" is first one. */
2409 else
2410 frameno = traceframe_number + 1;
2411 }
2412 else if (0 == strcmp (args, "-"))
2413 {
2414 if (traceframe_number == -1)
2415 error (_("not debugging trace buffer"));
2416 else if (from_tty && traceframe_number == 0)
2417 error (_("already at start of trace buffer"));
2418
2419 frameno = traceframe_number - 1;
2420 }
2421 /* A hack to work around eval's need for fp to have been collected. */
2422 else if (0 == strcmp (args, "-1"))
2423 frameno = -1;
2424 else
2425 frameno = parse_and_eval_long (args);
2426
2427 if (frameno < -1)
2428 error (_("invalid input (%d is less than zero)"), frameno);
2429
2430 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2431 }
2432
2433 /* tfind end */
2434 static void
2435 trace_find_end_command (char *args, int from_tty)
2436 {
2437 trace_find_command ("-1", from_tty);
2438 }
2439
2440 /* tfind start */
2441 static void
2442 trace_find_start_command (char *args, int from_tty)
2443 {
2444 trace_find_command ("0", from_tty);
2445 }
2446
2447 /* tfind pc command */
2448 static void
2449 trace_find_pc_command (char *args, int from_tty)
2450 {
2451 CORE_ADDR pc;
2452
2453 if (current_trace_status ()->running
2454 && current_trace_status ()->filename == NULL)
2455 error (_("May not look at trace frames while trace is running."));
2456
2457 if (args == 0 || *args == 0)
2458 pc = regcache_read_pc (get_current_regcache ());
2459 else
2460 pc = parse_and_eval_address (args);
2461
2462 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2463 }
2464
2465 /* tfind tracepoint command */
2466 static void
2467 trace_find_tracepoint_command (char *args, int from_tty)
2468 {
2469 int tdp;
2470 struct tracepoint *tp;
2471
2472 if (current_trace_status ()->running
2473 && current_trace_status ()->filename == NULL)
2474 error (_("May not look at trace frames while trace is running."));
2475
2476 if (args == 0 || *args == 0)
2477 {
2478 if (tracepoint_number == -1)
2479 error (_("No current tracepoint -- please supply an argument."));
2480 else
2481 tdp = tracepoint_number; /* Default is current TDP. */
2482 }
2483 else
2484 tdp = parse_and_eval_long (args);
2485
2486 /* If we have the tracepoint on hand, use the number that the
2487 target knows about (which may be different if we disconnected
2488 and reconnected). */
2489 tp = get_tracepoint (tdp);
2490 if (tp)
2491 tdp = tp->number_on_target;
2492
2493 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2494 }
2495
2496 /* TFIND LINE command:
2497
2498 This command will take a sourceline for argument, just like BREAK
2499 or TRACE (ie. anything that "decode_line_1" can handle).
2500
2501 With no argument, this command will find the next trace frame
2502 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2503
2504 static void
2505 trace_find_line_command (char *args, int from_tty)
2506 {
2507 static CORE_ADDR start_pc, end_pc;
2508 struct symtabs_and_lines sals;
2509 struct symtab_and_line sal;
2510 struct cleanup *old_chain;
2511
2512 if (current_trace_status ()->running
2513 && current_trace_status ()->filename == NULL)
2514 error (_("May not look at trace frames while trace is running."));
2515
2516 if (args == 0 || *args == 0)
2517 {
2518 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2519 sals.nelts = 1;
2520 sals.sals = (struct symtab_and_line *)
2521 xmalloc (sizeof (struct symtab_and_line));
2522 sals.sals[0] = sal;
2523 }
2524 else
2525 {
2526 sals = decode_line_with_current_source (args, DECODE_LINE_FUNFIRSTLINE);
2527 sal = sals.sals[0];
2528 }
2529
2530 old_chain = make_cleanup (xfree, sals.sals);
2531 if (sal.symtab == 0)
2532 error (_("No line number information available."));
2533
2534 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2535 {
2536 if (start_pc == end_pc)
2537 {
2538 printf_filtered ("Line %d of \"%s\"",
2539 sal.line,
2540 symtab_to_filename_for_display (sal.symtab));
2541 wrap_here (" ");
2542 printf_filtered (" is at address ");
2543 print_address (get_current_arch (), start_pc, gdb_stdout);
2544 wrap_here (" ");
2545 printf_filtered (" but contains no code.\n");
2546 sal = find_pc_line (start_pc, 0);
2547 if (sal.line > 0
2548 && find_line_pc_range (sal, &start_pc, &end_pc)
2549 && start_pc != end_pc)
2550 printf_filtered ("Attempting to find line %d instead.\n",
2551 sal.line);
2552 else
2553 error (_("Cannot find a good line."));
2554 }
2555 }
2556 else
2557 /* Is there any case in which we get here, and have an address
2558 which the user would want to see? If we have debugging
2559 symbols and no line numbers? */
2560 error (_("Line number %d is out of range for \"%s\"."),
2561 sal.line, symtab_to_filename_for_display (sal.symtab));
2562
2563 /* Find within range of stated line. */
2564 if (args && *args)
2565 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2566 else
2567 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2568 do_cleanups (old_chain);
2569 }
2570
2571 /* tfind range command */
2572 static void
2573 trace_find_range_command (char *args, int from_tty)
2574 {
2575 static CORE_ADDR start, stop;
2576 char *tmp;
2577
2578 if (current_trace_status ()->running
2579 && current_trace_status ()->filename == NULL)
2580 error (_("May not look at trace frames while trace is running."));
2581
2582 if (args == 0 || *args == 0)
2583 { /* XXX FIXME: what should default behavior be? */
2584 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2585 return;
2586 }
2587
2588 if (0 != (tmp = strchr (args, ',')))
2589 {
2590 *tmp++ = '\0'; /* Terminate start address. */
2591 tmp = skip_spaces (tmp);
2592 start = parse_and_eval_address (args);
2593 stop = parse_and_eval_address (tmp);
2594 }
2595 else
2596 { /* No explicit end address? */
2597 start = parse_and_eval_address (args);
2598 stop = start + 1; /* ??? */
2599 }
2600
2601 tfind_1 (tfind_range, 0, start, stop, from_tty);
2602 }
2603
2604 /* tfind outside command */
2605 static void
2606 trace_find_outside_command (char *args, int from_tty)
2607 {
2608 CORE_ADDR start, stop;
2609 char *tmp;
2610
2611 if (current_trace_status ()->running
2612 && current_trace_status ()->filename == NULL)
2613 error (_("May not look at trace frames while trace is running."));
2614
2615 if (args == 0 || *args == 0)
2616 { /* XXX FIXME: what should default behavior be? */
2617 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2618 return;
2619 }
2620
2621 if (0 != (tmp = strchr (args, ',')))
2622 {
2623 *tmp++ = '\0'; /* Terminate start address. */
2624 tmp = skip_spaces (tmp);
2625 start = parse_and_eval_address (args);
2626 stop = parse_and_eval_address (tmp);
2627 }
2628 else
2629 { /* No explicit end address? */
2630 start = parse_and_eval_address (args);
2631 stop = start + 1; /* ??? */
2632 }
2633
2634 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2635 }
2636
2637 /* info scope command: list the locals for a scope. */
2638 static void
2639 scope_info (char *args, int from_tty)
2640 {
2641 struct symtabs_and_lines sals;
2642 struct symbol *sym;
2643 struct minimal_symbol *msym;
2644 struct block *block;
2645 const char *symname;
2646 char *save_args = args;
2647 struct block_iterator iter;
2648 int j, count = 0;
2649 struct gdbarch *gdbarch;
2650 int regno;
2651
2652 if (args == 0 || *args == 0)
2653 error (_("requires an argument (function, "
2654 "line or *addr) to define a scope"));
2655
2656 sals = decode_line_1 (&args, DECODE_LINE_FUNFIRSTLINE, NULL, 0);
2657 if (sals.nelts == 0)
2658 return; /* Presumably decode_line_1 has already warned. */
2659
2660 /* Resolve line numbers to PC. */
2661 resolve_sal_pc (&sals.sals[0]);
2662 block = block_for_pc (sals.sals[0].pc);
2663
2664 while (block != 0)
2665 {
2666 QUIT; /* Allow user to bail out with ^C. */
2667 ALL_BLOCK_SYMBOLS (block, iter, sym)
2668 {
2669 QUIT; /* Allow user to bail out with ^C. */
2670 if (count == 0)
2671 printf_filtered ("Scope for %s:\n", save_args);
2672 count++;
2673
2674 symname = SYMBOL_PRINT_NAME (sym);
2675 if (symname == NULL || *symname == '\0')
2676 continue; /* Probably botched, certainly useless. */
2677
2678 gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
2679
2680 printf_filtered ("Symbol %s is ", symname);
2681 switch (SYMBOL_CLASS (sym))
2682 {
2683 default:
2684 case LOC_UNDEF: /* Messed up symbol? */
2685 printf_filtered ("a bogus symbol, class %d.\n",
2686 SYMBOL_CLASS (sym));
2687 count--; /* Don't count this one. */
2688 continue;
2689 case LOC_CONST:
2690 printf_filtered ("a constant with value %s (%s)",
2691 plongest (SYMBOL_VALUE (sym)),
2692 hex_string (SYMBOL_VALUE (sym)));
2693 break;
2694 case LOC_CONST_BYTES:
2695 printf_filtered ("constant bytes: ");
2696 if (SYMBOL_TYPE (sym))
2697 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2698 fprintf_filtered (gdb_stdout, " %02x",
2699 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2700 break;
2701 case LOC_STATIC:
2702 printf_filtered ("in static storage at address ");
2703 printf_filtered ("%s", paddress (gdbarch,
2704 SYMBOL_VALUE_ADDRESS (sym)));
2705 break;
2706 case LOC_REGISTER:
2707 /* GDBARCH is the architecture associated with the objfile
2708 the symbol is defined in; the target architecture may be
2709 different, and may provide additional registers. However,
2710 we do not know the target architecture at this point.
2711 We assume the objfile architecture will contain all the
2712 standard registers that occur in debug info in that
2713 objfile. */
2714 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2715 gdbarch);
2716
2717 if (SYMBOL_IS_ARGUMENT (sym))
2718 printf_filtered ("an argument in register $%s",
2719 gdbarch_register_name (gdbarch, regno));
2720 else
2721 printf_filtered ("a local variable in register $%s",
2722 gdbarch_register_name (gdbarch, regno));
2723 break;
2724 case LOC_ARG:
2725 printf_filtered ("an argument at stack/frame offset %s",
2726 plongest (SYMBOL_VALUE (sym)));
2727 break;
2728 case LOC_LOCAL:
2729 printf_filtered ("a local variable at frame offset %s",
2730 plongest (SYMBOL_VALUE (sym)));
2731 break;
2732 case LOC_REF_ARG:
2733 printf_filtered ("a reference argument at offset %s",
2734 plongest (SYMBOL_VALUE (sym)));
2735 break;
2736 case LOC_REGPARM_ADDR:
2737 /* Note comment at LOC_REGISTER. */
2738 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2739 gdbarch);
2740 printf_filtered ("the address of an argument, in register $%s",
2741 gdbarch_register_name (gdbarch, regno));
2742 break;
2743 case LOC_TYPEDEF:
2744 printf_filtered ("a typedef.\n");
2745 continue;
2746 case LOC_LABEL:
2747 printf_filtered ("a label at address ");
2748 printf_filtered ("%s", paddress (gdbarch,
2749 SYMBOL_VALUE_ADDRESS (sym)));
2750 break;
2751 case LOC_BLOCK:
2752 printf_filtered ("a function at address ");
2753 printf_filtered ("%s",
2754 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2755 break;
2756 case LOC_UNRESOLVED:
2757 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2758 NULL, NULL);
2759 if (msym == NULL)
2760 printf_filtered ("Unresolved Static");
2761 else
2762 {
2763 printf_filtered ("static storage at address ");
2764 printf_filtered ("%s",
2765 paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msym)));
2766 }
2767 break;
2768 case LOC_OPTIMIZED_OUT:
2769 printf_filtered ("optimized out.\n");
2770 continue;
2771 case LOC_COMPUTED:
2772 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2773 BLOCK_START (block),
2774 gdb_stdout);
2775 break;
2776 }
2777 if (SYMBOL_TYPE (sym))
2778 printf_filtered (", length %d.\n",
2779 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2780 }
2781 if (BLOCK_FUNCTION (block))
2782 break;
2783 else
2784 block = BLOCK_SUPERBLOCK (block);
2785 }
2786 if (count <= 0)
2787 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2788 save_args);
2789 }
2790
2791 /* Helper for trace_dump_command. Dump the action list starting at
2792 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2793 actions of the body of a while-stepping action. STEPPING_FRAME is
2794 set if the current traceframe was determined to be a while-stepping
2795 traceframe. */
2796
2797 static void
2798 trace_dump_actions (struct command_line *action,
2799 int stepping_actions, int stepping_frame,
2800 int from_tty)
2801 {
2802 const char *action_exp, *next_comma;
2803
2804 for (; action != NULL; action = action->next)
2805 {
2806 struct cmd_list_element *cmd;
2807
2808 QUIT; /* Allow user to bail out with ^C. */
2809 action_exp = action->line;
2810 action_exp = skip_spaces_const (action_exp);
2811
2812 /* The collection actions to be done while stepping are
2813 bracketed by the commands "while-stepping" and "end". */
2814
2815 if (*action_exp == '#') /* comment line */
2816 continue;
2817
2818 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2819 if (cmd == 0)
2820 error (_("Bad action list item: %s"), action_exp);
2821
2822 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2823 {
2824 int i;
2825
2826 for (i = 0; i < action->body_count; ++i)
2827 trace_dump_actions (action->body_list[i],
2828 1, stepping_frame, from_tty);
2829 }
2830 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2831 {
2832 /* Display the collected data.
2833 For the trap frame, display only what was collected at
2834 the trap. Likewise for stepping frames, display only
2835 what was collected while stepping. This means that the
2836 two boolean variables, STEPPING_FRAME and
2837 STEPPING_ACTIONS should be equal. */
2838 if (stepping_frame == stepping_actions)
2839 {
2840 char *cmd = NULL;
2841 struct cleanup *old_chain
2842 = make_cleanup (free_current_contents, &cmd);
2843
2844 if (*action_exp == '/')
2845 action_exp = decode_agent_options (action_exp);
2846
2847 do
2848 { /* Repeat over a comma-separated list. */
2849 QUIT; /* Allow user to bail out with ^C. */
2850 if (*action_exp == ',')
2851 action_exp++;
2852 action_exp = skip_spaces_const (action_exp);
2853
2854 next_comma = strchr (action_exp, ',');
2855
2856 if (0 == strncasecmp (action_exp, "$reg", 4))
2857 registers_info (NULL, from_tty);
2858 else if (0 == strncasecmp (action_exp, "$_ret", 5))
2859 ;
2860 else if (0 == strncasecmp (action_exp, "$loc", 4))
2861 locals_info (NULL, from_tty);
2862 else if (0 == strncasecmp (action_exp, "$arg", 4))
2863 args_info (NULL, from_tty);
2864 else
2865 { /* variable */
2866 if (next_comma != NULL)
2867 {
2868 size_t len = next_comma - action_exp;
2869
2870 cmd = xrealloc (cmd, len + 1);
2871 memcpy (cmd, action_exp, len);
2872 cmd[len] = 0;
2873 }
2874 else
2875 {
2876 size_t len = strlen (action_exp);
2877
2878 cmd = xrealloc (cmd, len + 1);
2879 memcpy (cmd, action_exp, len + 1);
2880 }
2881
2882 printf_filtered ("%s = ", cmd);
2883 output_command_const (cmd, from_tty);
2884 printf_filtered ("\n");
2885 }
2886 action_exp = next_comma;
2887 }
2888 while (action_exp && *action_exp == ',');
2889
2890 do_cleanups (old_chain);
2891 }
2892 }
2893 }
2894 }
2895
2896 /* The tdump command. */
2897
2898 static void
2899 trace_dump_command (char *args, int from_tty)
2900 {
2901 struct regcache *regcache;
2902 struct tracepoint *t;
2903 int stepping_frame = 0;
2904 struct bp_location *loc;
2905 char *default_collect_line = NULL;
2906 struct command_line *actions, *default_collect_action = NULL;
2907 struct cleanup *old_chain = NULL;
2908
2909 if (tracepoint_number == -1)
2910 {
2911 warning (_("No current trace frame."));
2912 return;
2913 }
2914
2915 t = get_tracepoint (tracepoint_number);
2916
2917 if (t == NULL)
2918 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2919 tracepoint_number);
2920
2921 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2922 tracepoint_number, traceframe_number);
2923
2924 /* The current frame is a trap frame if the frame PC is equal
2925 to the tracepoint PC. If not, then the current frame was
2926 collected during single-stepping. */
2927
2928 regcache = get_current_regcache ();
2929
2930 /* If the traceframe's address matches any of the tracepoint's
2931 locations, assume it is a direct hit rather than a while-stepping
2932 frame. (FIXME this is not reliable, should record each frame's
2933 type.) */
2934 stepping_frame = 1;
2935 for (loc = t->base.loc; loc; loc = loc->next)
2936 if (loc->address == regcache_read_pc (regcache))
2937 stepping_frame = 0;
2938
2939 actions = breakpoint_commands (&t->base);
2940
2941 /* If there is a default-collect list, make up a collect command,
2942 prepend to the tracepoint's commands, and pass the whole mess to
2943 the trace dump scanner. We need to validate because
2944 default-collect might have been junked since the trace run. */
2945 if (*default_collect)
2946 {
2947 default_collect_line = xstrprintf ("collect %s", default_collect);
2948 old_chain = make_cleanup (xfree, default_collect_line);
2949 validate_actionline (default_collect_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 = default_collect_line;
2954 actions = default_collect_action;
2955 }
2956
2957 trace_dump_actions (actions, 0, stepping_frame, from_tty);
2958
2959 if (*default_collect)
2960 do_cleanups (old_chain);
2961 }
2962
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 */
2967
2968 extern int
2969 encode_source_string (int tpnum, ULONGEST addr,
2970 char *srctype, char *src, char *buf, int buf_size)
2971 {
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);
2980 return -1;
2981 }
2982
2983 /* Free trace file writer. */
2984
2985 static void
2986 trace_file_writer_xfree (void *arg)
2987 {
2988 struct trace_file_writer *writer = arg;
2989
2990 writer->ops->dtor (writer);
2991 xfree (writer);
2992 }
2993
2994 /* TFILE trace writer. */
2995
2996 struct tfile_trace_file_writer
2997 {
2998 struct trace_file_writer base;
2999
3000 /* File pointer to tfile trace file. */
3001 FILE *fp;
3002 /* Path name of the tfile trace file. */
3003 char *pathname;
3004 };
3005
3006 /* This is the implementation of trace_file_write_ops method
3007 target_save. We just call the generic target
3008 target_save_trace_data to do target-side saving. */
3009
3010 static int
3011 tfile_target_save (struct trace_file_writer *self,
3012 const char *filename)
3013 {
3014 int err = target_save_trace_data (filename);
3015
3016 return (err >= 0);
3017 }
3018
3019 /* This is the implementation of trace_file_write_ops method
3020 dtor. */
3021
3022 static void
3023 tfile_dtor (struct trace_file_writer *self)
3024 {
3025 struct tfile_trace_file_writer *writer
3026 = (struct tfile_trace_file_writer *) self;
3027
3028 xfree (writer->pathname);
3029
3030 if (writer->fp != NULL)
3031 fclose (writer->fp);
3032 }
3033
3034 /* This is the implementation of trace_file_write_ops method
3035 start. It creates the trace file FILENAME and registers some
3036 cleanups. */
3037
3038 static void
3039 tfile_start (struct trace_file_writer *self, const char *filename)
3040 {
3041 struct tfile_trace_file_writer *writer
3042 = (struct tfile_trace_file_writer *) self;
3043
3044 writer->pathname = tilde_expand (filename);
3045 writer->fp = fopen (writer->pathname, "wb");
3046 if (writer->fp == NULL)
3047 error (_("Unable to open file '%s' for saving trace data (%s)"),
3048 filename, safe_strerror (errno));
3049 }
3050
3051 /* This is the implementation of trace_file_write_ops method
3052 write_header. Write the TFILE header. */
3053
3054 static void
3055 tfile_write_header (struct trace_file_writer *self)
3056 {
3057 struct tfile_trace_file_writer *writer
3058 = (struct tfile_trace_file_writer *) self;
3059 int written;
3060
3061 /* Write a file header, with a high-bit-set char to indicate a
3062 binary file, plus a hint as what this file is, and a version
3063 number in case of future needs. */
3064 written = fwrite ("\x7fTRACE0\n", 8, 1, writer->fp);
3065 if (written < 1)
3066 perror_with_name (writer->pathname);
3067 }
3068
3069 /* This is the implementation of trace_file_write_ops method
3070 write_regblock_type. Write the size of register block. */
3071
3072 static void
3073 tfile_write_regblock_type (struct trace_file_writer *self, int size)
3074 {
3075 struct tfile_trace_file_writer *writer
3076 = (struct tfile_trace_file_writer *) self;
3077
3078 fprintf (writer->fp, "R %x\n", size);
3079 }
3080
3081 /* This is the implementation of trace_file_write_ops method
3082 write_status. */
3083
3084 static void
3085 tfile_write_status (struct trace_file_writer *self,
3086 struct trace_status *ts)
3087 {
3088 struct tfile_trace_file_writer *writer
3089 = (struct tfile_trace_file_writer *) self;
3090
3091 fprintf (writer->fp, "status %c;%s",
3092 (ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
3093 if (ts->stop_reason == tracepoint_error
3094 || ts->stop_reason == tstop_command)
3095 {
3096 char *buf = (char *) alloca (strlen (ts->stop_desc) * 2 + 1);
3097
3098 bin2hex ((gdb_byte *) ts->stop_desc, buf, 0);
3099 fprintf (writer->fp, ":%s", buf);
3100 }
3101 fprintf (writer->fp, ":%x", ts->stopping_tracepoint);
3102 if (ts->traceframe_count >= 0)
3103 fprintf (writer->fp, ";tframes:%x", ts->traceframe_count);
3104 if (ts->traceframes_created >= 0)
3105 fprintf (writer->fp, ";tcreated:%x", ts->traceframes_created);
3106 if (ts->buffer_free >= 0)
3107 fprintf (writer->fp, ";tfree:%x", ts->buffer_free);
3108 if (ts->buffer_size >= 0)
3109 fprintf (writer->fp, ";tsize:%x", ts->buffer_size);
3110 if (ts->disconnected_tracing)
3111 fprintf (writer->fp, ";disconn:%x", ts->disconnected_tracing);
3112 if (ts->circular_buffer)
3113 fprintf (writer->fp, ";circular:%x", ts->circular_buffer);
3114 if (ts->notes != NULL)
3115 {
3116 char *buf = (char *) alloca (strlen (ts->notes) * 2 + 1);
3117
3118 bin2hex ((gdb_byte *) ts->notes, buf, 0);
3119 fprintf (writer->fp, ";notes:%s", buf);
3120 }
3121 if (ts->user_name != NULL)
3122 {
3123 char *buf = (char *) alloca (strlen (ts->user_name) * 2 + 1);
3124
3125 bin2hex ((gdb_byte *) ts->user_name, buf, 0);
3126 fprintf (writer->fp, ";username:%s", buf);
3127 }
3128 fprintf (writer->fp, "\n");
3129 }
3130
3131 /* This is the implementation of trace_file_write_ops method
3132 write_uploaded_tsv. */
3133
3134 static void
3135 tfile_write_uploaded_tsv (struct trace_file_writer *self,
3136 struct uploaded_tsv *utsv)
3137 {
3138 char *buf = "";
3139 struct tfile_trace_file_writer *writer
3140 = (struct tfile_trace_file_writer *) self;
3141
3142 if (utsv->name)
3143 {
3144 buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
3145 bin2hex ((gdb_byte *) (utsv->name), buf, 0);
3146 }
3147
3148 fprintf (writer->fp, "tsv %x:%s:%x:%s\n",
3149 utsv->number, phex_nz (utsv->initial_value, 8),
3150 utsv->builtin, buf);
3151
3152 if (utsv->name)
3153 xfree (buf);
3154 }
3155
3156 #define MAX_TRACE_UPLOAD 2000
3157
3158 /* This is the implementation of trace_file_write_ops method
3159 write_uploaded_tp. */
3160
3161 static void
3162 tfile_write_uploaded_tp (struct trace_file_writer *self,
3163 struct uploaded_tp *utp)
3164 {
3165 struct tfile_trace_file_writer *writer
3166 = (struct tfile_trace_file_writer *) self;
3167 int a;
3168 char *act;
3169 gdb_byte buf[MAX_TRACE_UPLOAD];
3170
3171 fprintf (writer->fp, "tp T%x:%s:%c:%x:%x",
3172 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
3173 (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
3174 if (utp->type == bp_fast_tracepoint)
3175 fprintf (writer->fp, ":F%x", utp->orig_size);
3176 if (utp->cond)
3177 fprintf (writer->fp,
3178 ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
3179 utp->cond);
3180 fprintf (writer->fp, "\n");
3181 for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
3182 fprintf (writer->fp, "tp A%x:%s:%s\n",
3183 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
3184 for (a = 0; VEC_iterate (char_ptr, utp->step_actions, a, act); ++a)
3185 fprintf (writer->fp, "tp S%x:%s:%s\n",
3186 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
3187 if (utp->at_string)
3188 {
3189 encode_source_string (utp->number, utp->addr,
3190 "at", utp->at_string, buf, MAX_TRACE_UPLOAD);
3191 fprintf (writer->fp, "tp Z%s\n", buf);
3192 }
3193 if (utp->cond_string)
3194 {
3195 encode_source_string (utp->number, utp->addr,
3196 "cond", utp->cond_string,
3197 buf, MAX_TRACE_UPLOAD);
3198 fprintf (writer->fp, "tp Z%s\n", buf);
3199 }
3200 for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
3201 {
3202 encode_source_string (utp->number, utp->addr, "cmd", act,
3203 buf, MAX_TRACE_UPLOAD);
3204 fprintf (writer->fp, "tp Z%s\n", buf);
3205 }
3206 fprintf (writer->fp, "tp V%x:%s:%x:%s\n",
3207 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
3208 utp->hit_count,
3209 phex_nz (utp->traceframe_usage,
3210 sizeof (utp->traceframe_usage)));
3211 }
3212
3213 /* This is the implementation of trace_file_write_ops method
3214 write_definition_end. */
3215
3216 static void
3217 tfile_write_definition_end (struct trace_file_writer *self)
3218 {
3219 struct tfile_trace_file_writer *writer
3220 = (struct tfile_trace_file_writer *) self;
3221
3222 fprintf (writer->fp, "\n");
3223 }
3224
3225 /* This is the implementation of trace_file_write_ops method
3226 write_raw_data. */
3227
3228 static void
3229 tfile_write_raw_data (struct trace_file_writer *self, gdb_byte *buf,
3230 LONGEST len)
3231 {
3232 struct tfile_trace_file_writer *writer
3233 = (struct tfile_trace_file_writer *) self;
3234
3235 if (fwrite (buf, len, 1, writer->fp) < 1)
3236 perror_with_name (writer->pathname);
3237 }
3238
3239 /* This is the implementation of trace_file_write_ops method
3240 end. */
3241
3242 static void
3243 tfile_end (struct trace_file_writer *self)
3244 {
3245 struct tfile_trace_file_writer *writer
3246 = (struct tfile_trace_file_writer *) self;
3247 uint32_t gotten = 0;
3248
3249 /* Mark the end of trace data. */
3250 if (fwrite (&gotten, 4, 1, writer->fp) < 1)
3251 perror_with_name (writer->pathname);
3252 }
3253
3254 /* Operations to write trace buffers into TFILE format. */
3255
3256 static const struct trace_file_write_ops tfile_write_ops =
3257 {
3258 tfile_dtor,
3259 tfile_target_save,
3260 tfile_start,
3261 tfile_write_header,
3262 tfile_write_regblock_type,
3263 tfile_write_status,
3264 tfile_write_uploaded_tsv,
3265 tfile_write_uploaded_tp,
3266 tfile_write_definition_end,
3267 tfile_write_raw_data,
3268 NULL,
3269 tfile_end,
3270 };
3271
3272 /* Helper macros. */
3273
3274 #define TRACE_WRITE_R_BLOCK(writer, buf, size) \
3275 writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
3276 #define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size) \
3277 writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
3278 (size))
3279 #define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size) \
3280 writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
3281 (size))
3282 #define TRACE_WRITE_V_BLOCK(writer, num, val) \
3283 writer->ops->frame_ops->write_v_block ((writer), (num), (val))
3284
3285 extern int trace_regblock_size;
3286
3287 /* Save tracepoint data to file named FILENAME through WRITER. WRITER
3288 determines the trace file format. If TARGET_DOES_SAVE is non-zero,
3289 the save is performed on the target, otherwise GDB obtains all trace
3290 data and saves it locally. */
3291
3292 static void
3293 trace_save (const char *filename, struct trace_file_writer *writer,
3294 int target_does_save)
3295 {
3296 struct trace_status *ts = current_trace_status ();
3297 int status;
3298 struct uploaded_tp *uploaded_tps = NULL, *utp;
3299 struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
3300
3301 ULONGEST offset = 0;
3302 gdb_byte buf[MAX_TRACE_UPLOAD];
3303 int written;
3304 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
3305
3306 /* If the target is to save the data to a file on its own, then just
3307 send the command and be done with it. */
3308 if (target_does_save)
3309 {
3310 if (!writer->ops->target_save (writer, filename))
3311 error (_("Target failed to save trace data to '%s'."),
3312 filename);
3313 return;
3314 }
3315
3316 /* Get the trace status first before opening the file, so if the
3317 target is losing, we can get out without touching files. */
3318 status = target_get_trace_status (ts);
3319
3320 writer->ops->start (writer, filename);
3321
3322 writer->ops->write_header (writer);
3323
3324 /* Write descriptive info. */
3325
3326 /* Write out the size of a register block. */
3327 writer->ops->write_regblock_type (writer, trace_regblock_size);
3328
3329 /* Write out status of the tracing run (aka "tstatus" info). */
3330 writer->ops->write_status (writer, ts);
3331
3332 /* Note that we want to upload tracepoints and save those, rather
3333 than simply writing out the local ones, because the user may have
3334 changed tracepoints in GDB in preparation for a future tracing
3335 run, or maybe just mass-deleted all types of breakpoints as part
3336 of cleaning up. So as not to contaminate the session, leave the
3337 data in its uploaded form, don't make into real tracepoints. */
3338
3339 /* Get trace state variables first, they may be checked when parsing
3340 uploaded commands. */
3341
3342 target_upload_trace_state_variables (&uploaded_tsvs);
3343
3344 for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
3345 writer->ops->write_uploaded_tsv (writer, utsv);
3346
3347 free_uploaded_tsvs (&uploaded_tsvs);
3348
3349 target_upload_tracepoints (&uploaded_tps);
3350
3351 for (utp = uploaded_tps; utp; utp = utp->next)
3352 target_get_tracepoint_status (NULL, utp);
3353
3354 for (utp = uploaded_tps; utp; utp = utp->next)
3355 writer->ops->write_uploaded_tp (writer, utp);
3356
3357 free_uploaded_tps (&uploaded_tps);
3358
3359 /* Mark the end of the definition section. */
3360 writer->ops->write_definition_end (writer);
3361
3362 /* Get and write the trace data proper. */
3363 while (1)
3364 {
3365 LONGEST gotten = 0;
3366
3367 /* The writer supports writing the contents of trace buffer
3368 directly to trace file. Don't parse the contents of trace
3369 buffer. */
3370 if (writer->ops->write_trace_buffer != NULL)
3371 {
3372 /* We ask for big blocks, in the hopes of efficiency, but
3373 will take less if the target has packet size limitations
3374 or some such. */
3375 gotten = target_get_raw_trace_data (buf, offset,
3376 MAX_TRACE_UPLOAD);
3377 if (gotten < 0)
3378 error (_("Failure to get requested trace buffer data"));
3379 /* No more data is forthcoming, we're done. */
3380 if (gotten == 0)
3381 break;
3382
3383 writer->ops->write_trace_buffer (writer, buf, gotten);
3384
3385 offset += gotten;
3386 }
3387 else
3388 {
3389 uint16_t tp_num;
3390 uint32_t tf_size;
3391 /* Parse the trace buffers according to how data are stored
3392 in trace buffer in GDBserver. */
3393
3394 gotten = target_get_raw_trace_data (buf, offset, 6);
3395
3396 if (gotten == 0)
3397 break;
3398
3399 /* Read the first six bytes in, which is the tracepoint
3400 number and trace frame size. */
3401 tp_num = (uint16_t)
3402 extract_unsigned_integer (&buf[0], 2, byte_order);
3403
3404 tf_size = (uint32_t)
3405 extract_unsigned_integer (&buf[2], 4, byte_order);
3406
3407 writer->ops->frame_ops->start (writer, tp_num);
3408 gotten = 6;
3409
3410 if (tf_size > 0)
3411 {
3412 unsigned int block;
3413
3414 offset += 6;
3415
3416 for (block = 0; block < tf_size; )
3417 {
3418 gdb_byte block_type;
3419
3420 /* We'll fetch one block each time, in order to
3421 handle the extremely large 'M' block. We first
3422 fetch one byte to get the type of the block. */
3423 gotten = target_get_raw_trace_data (buf, offset, 1);
3424 if (gotten < 1)
3425 error (_("Failure to get requested trace buffer data"));
3426
3427 gotten = 1;
3428 block += 1;
3429 offset += 1;
3430
3431 block_type = buf[0];
3432 switch (block_type)
3433 {
3434 case 'R':
3435 gotten
3436 = target_get_raw_trace_data (buf, offset,
3437 trace_regblock_size);
3438 if (gotten < trace_regblock_size)
3439 error (_("Failure to get requested trace"
3440 " buffer data"));
3441
3442 TRACE_WRITE_R_BLOCK (writer, buf,
3443 trace_regblock_size);
3444 break;
3445 case 'M':
3446 {
3447 unsigned short mlen;
3448 ULONGEST addr;
3449 LONGEST t;
3450 int j;
3451
3452 t = target_get_raw_trace_data (buf,offset, 10);
3453 if (t < 10)
3454 error (_("Failure to get requested trace"
3455 " buffer data"));
3456
3457 offset += 10;
3458 block += 10;
3459
3460 gotten = 0;
3461 addr = (ULONGEST)
3462 extract_unsigned_integer (buf, 8,
3463 byte_order);
3464 mlen = (unsigned short)
3465 extract_unsigned_integer (&buf[8], 2,
3466 byte_order);
3467
3468 TRACE_WRITE_M_BLOCK_HEADER (writer, addr,
3469 mlen);
3470
3471 /* The memory contents in 'M' block may be
3472 very large. Fetch the data from the target
3473 and write them into file one by one. */
3474 for (j = 0; j < mlen; )
3475 {
3476 unsigned int read_length;
3477
3478 if (mlen - j > MAX_TRACE_UPLOAD)
3479 read_length = MAX_TRACE_UPLOAD;
3480 else
3481 read_length = mlen - j;
3482
3483 t = target_get_raw_trace_data (buf,
3484 offset + j,
3485 read_length);
3486 if (t < read_length)
3487 error (_("Failure to get requested"
3488 " trace buffer data"));
3489
3490 TRACE_WRITE_M_BLOCK_MEMORY (writer, buf,
3491 read_length);
3492
3493 j += read_length;
3494 gotten += read_length;
3495 }
3496
3497 break;
3498 }
3499 case 'V':
3500 {
3501 int vnum;
3502 LONGEST val;
3503
3504 gotten
3505 = target_get_raw_trace_data (buf, offset,
3506 12);
3507 if (gotten < 12)
3508 error (_("Failure to get requested"
3509 " trace buffer data"));
3510
3511 vnum = (int) extract_signed_integer (buf,
3512 4,
3513 byte_order);
3514 val
3515 = extract_signed_integer (&buf[4], 8,
3516 byte_order);
3517
3518 TRACE_WRITE_V_BLOCK (writer, vnum, val);
3519 }
3520 break;
3521 default:
3522 error (_("Unknown block type '%c' (0x%x) in"
3523 " trace frame"),
3524 block_type, block_type);
3525 }
3526
3527 block += gotten;
3528 offset += gotten;
3529 }
3530 }
3531 else
3532 offset += gotten;
3533
3534 writer->ops->frame_ops->end (writer);
3535 }
3536 }
3537
3538 writer->ops->end (writer);
3539 }
3540
3541 /* Return a trace writer for TFILE format. */
3542
3543 static struct trace_file_writer *
3544 tfile_trace_file_writer_new (void)
3545 {
3546 struct tfile_trace_file_writer *writer
3547 = xmalloc (sizeof (struct tfile_trace_file_writer));
3548
3549 writer->base.ops = &tfile_write_ops;
3550 writer->fp = NULL;
3551 writer->pathname = NULL;
3552
3553 return (struct trace_file_writer *) writer;
3554 }
3555
3556 static void
3557 trace_save_command (char *args, int from_tty)
3558 {
3559 int target_does_save = 0;
3560 char **argv;
3561 char *filename = NULL;
3562 struct cleanup *back_to;
3563 int generate_ctf = 0;
3564 struct trace_file_writer *writer = NULL;
3565
3566 if (args == NULL)
3567 error_no_arg (_("file in which to save trace data"));
3568
3569 argv = gdb_buildargv (args);
3570 back_to = make_cleanup_freeargv (argv);
3571
3572 for (; *argv; ++argv)
3573 {
3574 if (strcmp (*argv, "-r") == 0)
3575 target_does_save = 1;
3576 if (strcmp (*argv, "-ctf") == 0)
3577 generate_ctf = 1;
3578 else if (**argv == '-')
3579 error (_("unknown option `%s'"), *argv);
3580 else
3581 filename = *argv;
3582 }
3583
3584 if (!filename)
3585 error_no_arg (_("file in which to save trace data"));
3586
3587 if (generate_ctf)
3588 writer = ctf_trace_file_writer_new ();
3589 else
3590 writer = tfile_trace_file_writer_new ();
3591
3592 make_cleanup (trace_file_writer_xfree, writer);
3593
3594 trace_save (filename, writer, target_does_save);
3595
3596 if (from_tty)
3597 printf_filtered (_("Trace data saved to %s '%s'.\n"),
3598 generate_ctf ? "directory" : "file", filename);
3599
3600 do_cleanups (back_to);
3601 }
3602
3603 /* Save the trace data to file FILENAME of tfile format. */
3604
3605 void
3606 trace_save_tfile (const char *filename, int target_does_save)
3607 {
3608 struct trace_file_writer *writer;
3609 struct cleanup *back_to;
3610
3611 writer = tfile_trace_file_writer_new ();
3612 back_to = make_cleanup (trace_file_writer_xfree, writer);
3613 trace_save (filename, writer, target_does_save);
3614 do_cleanups (back_to);
3615 }
3616
3617 /* Save the trace data to dir DIRNAME of ctf format. */
3618
3619 void
3620 trace_save_ctf (const char *dirname, int target_does_save)
3621 {
3622 struct trace_file_writer *writer;
3623 struct cleanup *back_to;
3624
3625 writer = ctf_trace_file_writer_new ();
3626 back_to = make_cleanup (trace_file_writer_xfree, writer);
3627
3628 trace_save (dirname, writer, target_does_save);
3629 do_cleanups (back_to);
3630 }
3631
3632 /* Tell the target what to do with an ongoing tracing run if GDB
3633 disconnects for some reason. */
3634
3635 static void
3636 set_disconnected_tracing (char *args, int from_tty,
3637 struct cmd_list_element *c)
3638 {
3639 target_set_disconnected_tracing (disconnected_tracing);
3640 }
3641
3642 static void
3643 set_circular_trace_buffer (char *args, int from_tty,
3644 struct cmd_list_element *c)
3645 {
3646 target_set_circular_trace_buffer (circular_trace_buffer);
3647 }
3648
3649 static void
3650 set_trace_buffer_size (char *args, int from_tty,
3651 struct cmd_list_element *c)
3652 {
3653 target_set_trace_buffer_size (trace_buffer_size);
3654 }
3655
3656 static void
3657 set_trace_user (char *args, int from_tty,
3658 struct cmd_list_element *c)
3659 {
3660 int ret;
3661
3662 ret = target_set_trace_notes (trace_user, NULL, NULL);
3663
3664 if (!ret)
3665 warning (_("Target does not support trace notes, user ignored"));
3666 }
3667
3668 static void
3669 set_trace_notes (char *args, int from_tty,
3670 struct cmd_list_element *c)
3671 {
3672 int ret;
3673
3674 ret = target_set_trace_notes (NULL, trace_notes, NULL);
3675
3676 if (!ret)
3677 warning (_("Target does not support trace notes, note ignored"));
3678 }
3679
3680 static void
3681 set_trace_stop_notes (char *args, int from_tty,
3682 struct cmd_list_element *c)
3683 {
3684 int ret;
3685
3686 ret = target_set_trace_notes (NULL, NULL, trace_stop_notes);
3687
3688 if (!ret)
3689 warning (_("Target does not support trace notes, stop note ignored"));
3690 }
3691
3692 /* Convert the memory pointed to by mem into hex, placing result in buf.
3693 * Return a pointer to the last char put in buf (null)
3694 * "stolen" from sparc-stub.c
3695 */
3696
3697 static const char hexchars[] = "0123456789abcdef";
3698
3699 static char *
3700 mem2hex (gdb_byte *mem, char *buf, int count)
3701 {
3702 gdb_byte ch;
3703
3704 while (count-- > 0)
3705 {
3706 ch = *mem++;
3707
3708 *buf++ = hexchars[ch >> 4];
3709 *buf++ = hexchars[ch & 0xf];
3710 }
3711
3712 *buf = 0;
3713
3714 return buf;
3715 }
3716
3717 int
3718 get_traceframe_number (void)
3719 {
3720 return traceframe_number;
3721 }
3722
3723 /* Make the traceframe NUM be the current trace frame. Does nothing
3724 if NUM is already current. */
3725
3726 void
3727 set_current_traceframe (int num)
3728 {
3729 int newnum;
3730
3731 if (traceframe_number == num)
3732 {
3733 /* Nothing to do. */
3734 return;
3735 }
3736
3737 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
3738
3739 if (newnum != num)
3740 warning (_("could not change traceframe"));
3741
3742 set_traceframe_num (newnum);
3743
3744 /* Changing the traceframe changes our view of registers and of the
3745 frame chain. */
3746 registers_changed ();
3747
3748 clear_traceframe_info ();
3749 }
3750
3751 /* Make the traceframe NUM be the current trace frame, and do nothing
3752 more. */
3753
3754 void
3755 set_traceframe_number (int num)
3756 {
3757 traceframe_number = num;
3758 }
3759
3760 /* A cleanup used when switching away and back from tfind mode. */
3761
3762 struct current_traceframe_cleanup
3763 {
3764 /* The traceframe we were inspecting. */
3765 int traceframe_number;
3766 };
3767
3768 static void
3769 do_restore_current_traceframe_cleanup (void *arg)
3770 {
3771 struct current_traceframe_cleanup *old = arg;
3772
3773 set_current_traceframe (old->traceframe_number);
3774 }
3775
3776 static void
3777 restore_current_traceframe_cleanup_dtor (void *arg)
3778 {
3779 struct current_traceframe_cleanup *old = arg;
3780
3781 xfree (old);
3782 }
3783
3784 struct cleanup *
3785 make_cleanup_restore_current_traceframe (void)
3786 {
3787 struct current_traceframe_cleanup *old;
3788
3789 old = xmalloc (sizeof (struct current_traceframe_cleanup));
3790 old->traceframe_number = traceframe_number;
3791
3792 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
3793 restore_current_traceframe_cleanup_dtor);
3794 }
3795
3796 struct cleanup *
3797 make_cleanup_restore_traceframe_number (void)
3798 {
3799 return make_cleanup_restore_integer (&traceframe_number);
3800 }
3801
3802 /* Given a number and address, return an uploaded tracepoint with that
3803 number, creating if necessary. */
3804
3805 struct uploaded_tp *
3806 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
3807 {
3808 struct uploaded_tp *utp;
3809
3810 for (utp = *utpp; utp; utp = utp->next)
3811 if (utp->number == num && utp->addr == addr)
3812 return utp;
3813 utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
3814 memset (utp, 0, sizeof (struct uploaded_tp));
3815 utp->number = num;
3816 utp->addr = addr;
3817 utp->actions = NULL;
3818 utp->step_actions = NULL;
3819 utp->cmd_strings = NULL;
3820 utp->next = *utpp;
3821 *utpp = utp;
3822 return utp;
3823 }
3824
3825 static void
3826 free_uploaded_tps (struct uploaded_tp **utpp)
3827 {
3828 struct uploaded_tp *next_one;
3829
3830 while (*utpp)
3831 {
3832 next_one = (*utpp)->next;
3833 xfree (*utpp);
3834 *utpp = next_one;
3835 }
3836 }
3837
3838 /* Given a number and address, return an uploaded tracepoint with that
3839 number, creating if necessary. */
3840
3841 static struct uploaded_tsv *
3842 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
3843 {
3844 struct uploaded_tsv *utsv;
3845
3846 for (utsv = *utsvp; utsv; utsv = utsv->next)
3847 if (utsv->number == num)
3848 return utsv;
3849 utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
3850 memset (utsv, 0, sizeof (struct uploaded_tsv));
3851 utsv->number = num;
3852 utsv->next = *utsvp;
3853 *utsvp = utsv;
3854 return utsv;
3855 }
3856
3857 static void
3858 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3859 {
3860 struct uploaded_tsv *next_one;
3861
3862 while (*utsvp)
3863 {
3864 next_one = (*utsvp)->next;
3865 xfree (*utsvp);
3866 *utsvp = next_one;
3867 }
3868 }
3869
3870 /* FIXME this function is heuristic and will miss the cases where the
3871 conditional is semantically identical but differs in whitespace,
3872 such as "x == 0" vs "x==0". */
3873
3874 static int
3875 cond_string_is_same (char *str1, char *str2)
3876 {
3877 if (str1 == NULL || str2 == NULL)
3878 return (str1 == str2);
3879
3880 return (strcmp (str1, str2) == 0);
3881 }
3882
3883 /* Look for an existing tracepoint that seems similar enough to the
3884 uploaded one. Enablement isn't compared, because the user can
3885 toggle that freely, and may have done so in anticipation of the
3886 next trace run. Return the location of matched tracepoint. */
3887
3888 static struct bp_location *
3889 find_matching_tracepoint_location (struct uploaded_tp *utp)
3890 {
3891 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
3892 int ix;
3893 struct breakpoint *b;
3894 struct bp_location *loc;
3895
3896 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
3897 {
3898 struct tracepoint *t = (struct tracepoint *) b;
3899
3900 if (b->type == utp->type
3901 && t->step_count == utp->step
3902 && t->pass_count == utp->pass
3903 && cond_string_is_same (t->base.cond_string, utp->cond_string)
3904 /* FIXME also test actions. */
3905 )
3906 {
3907 /* Scan the locations for an address match. */
3908 for (loc = b->loc; loc; loc = loc->next)
3909 {
3910 if (loc->address == utp->addr)
3911 return loc;
3912 }
3913 }
3914 }
3915 return NULL;
3916 }
3917
3918 /* Given a list of tracepoints uploaded from a target, attempt to
3919 match them up with existing tracepoints, and create new ones if not
3920 found. */
3921
3922 void
3923 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3924 {
3925 struct uploaded_tp *utp;
3926 /* A set of tracepoints which are modified. */
3927 VEC(breakpoint_p) *modified_tp = NULL;
3928 int ix;
3929 struct breakpoint *b;
3930
3931 /* Look for GDB tracepoints that match up with our uploaded versions. */
3932 for (utp = *uploaded_tps; utp; utp = utp->next)
3933 {
3934 struct bp_location *loc;
3935 struct tracepoint *t;
3936
3937 loc = find_matching_tracepoint_location (utp);
3938 if (loc)
3939 {
3940 int found = 0;
3941
3942 /* Mark this location as already inserted. */
3943 loc->inserted = 1;
3944 t = (struct tracepoint *) loc->owner;
3945 printf_filtered (_("Assuming tracepoint %d is same "
3946 "as target's tracepoint %d at %s.\n"),
3947 loc->owner->number, utp->number,
3948 paddress (loc->gdbarch, utp->addr));
3949
3950 /* The tracepoint LOC->owner was modified (the location LOC
3951 was marked as inserted in the target). Save it in
3952 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3953 observers will be notified later once for each tracepoint
3954 saved in MODIFIED_TP. */
3955 for (ix = 0;
3956 VEC_iterate (breakpoint_p, modified_tp, ix, b);
3957 ix++)
3958 if (b == loc->owner)
3959 {
3960 found = 1;
3961 break;
3962 }
3963 if (!found)
3964 VEC_safe_push (breakpoint_p, modified_tp, loc->owner);
3965 }
3966 else
3967 {
3968 t = create_tracepoint_from_upload (utp);
3969 if (t)
3970 printf_filtered (_("Created tracepoint %d for "
3971 "target's tracepoint %d at %s.\n"),
3972 t->base.number, utp->number,
3973 paddress (get_current_arch (), utp->addr));
3974 else
3975 printf_filtered (_("Failed to create tracepoint for target's "
3976 "tracepoint %d at %s, skipping it.\n"),
3977 utp->number,
3978 paddress (get_current_arch (), utp->addr));
3979 }
3980 /* Whether found or created, record the number used by the
3981 target, to help with mapping target tracepoints back to their
3982 counterparts here. */
3983 if (t)
3984 t->number_on_target = utp->number;
3985 }
3986
3987 /* Notify 'breakpoint-modified' observer that at least one of B's
3988 locations was changed. */
3989 for (ix = 0; VEC_iterate (breakpoint_p, modified_tp, ix, b); ix++)
3990 observer_notify_breakpoint_modified (b);
3991
3992 VEC_free (breakpoint_p, modified_tp);
3993 free_uploaded_tps (uploaded_tps);
3994 }
3995
3996 /* Trace state variables don't have much to identify them beyond their
3997 name, so just use that to detect matches. */
3998
3999 static struct trace_state_variable *
4000 find_matching_tsv (struct uploaded_tsv *utsv)
4001 {
4002 if (!utsv->name)
4003 return NULL;
4004
4005 return find_trace_state_variable (utsv->name);
4006 }
4007
4008 static struct trace_state_variable *
4009 create_tsv_from_upload (struct uploaded_tsv *utsv)
4010 {
4011 const char *namebase;
4012 char *buf;
4013 int try_num = 0;
4014 struct trace_state_variable *tsv;
4015 struct cleanup *old_chain;
4016
4017 if (utsv->name)
4018 {
4019 namebase = utsv->name;
4020 buf = xstrprintf ("%s", namebase);
4021 }
4022 else
4023 {
4024 namebase = "__tsv";
4025 buf = xstrprintf ("%s_%d", namebase, try_num++);
4026 }
4027
4028 /* Fish for a name that is not in use. */
4029 /* (should check against all internal vars?) */
4030 while (find_trace_state_variable (buf))
4031 {
4032 xfree (buf);
4033 buf = xstrprintf ("%s_%d", namebase, try_num++);
4034 }
4035
4036 old_chain = make_cleanup (xfree, buf);
4037
4038 /* We have an available name, create the variable. */
4039 tsv = create_trace_state_variable (buf);
4040 tsv->initial_value = utsv->initial_value;
4041 tsv->builtin = utsv->builtin;
4042
4043 observer_notify_tsv_created (tsv);
4044
4045 do_cleanups (old_chain);
4046
4047 return tsv;
4048 }
4049
4050 /* Given a list of uploaded trace state variables, try to match them
4051 up with existing variables, or create additional ones. */
4052
4053 void
4054 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
4055 {
4056 int ix;
4057 struct uploaded_tsv *utsv;
4058 struct trace_state_variable *tsv;
4059 int highest;
4060
4061 /* Most likely some numbers will have to be reassigned as part of
4062 the merge, so clear them all in anticipation. */
4063 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
4064 tsv->number = 0;
4065
4066 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
4067 {
4068 tsv = find_matching_tsv (utsv);
4069 if (tsv)
4070 {
4071 if (info_verbose)
4072 printf_filtered (_("Assuming trace state variable $%s "
4073 "is same as target's variable %d.\n"),
4074 tsv->name, utsv->number);
4075 }
4076 else
4077 {
4078 tsv = create_tsv_from_upload (utsv);
4079 if (info_verbose)
4080 printf_filtered (_("Created trace state variable "
4081 "$%s for target's variable %d.\n"),
4082 tsv->name, utsv->number);
4083 }
4084 /* Give precedence to numberings that come from the target. */
4085 if (tsv)
4086 tsv->number = utsv->number;
4087 }
4088
4089 /* Renumber everything that didn't get a target-assigned number. */
4090 highest = 0;
4091 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
4092 if (tsv->number > highest)
4093 highest = tsv->number;
4094
4095 ++highest;
4096 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
4097 if (tsv->number == 0)
4098 tsv->number = highest++;
4099
4100 free_uploaded_tsvs (uploaded_tsvs);
4101 }
4102
4103 /* target tfile command */
4104
4105 static struct target_ops tfile_ops;
4106
4107 /* Fill in tfile_ops with its defined operations and properties. */
4108
4109 #define TRACE_HEADER_SIZE 8
4110
4111 static char *trace_filename;
4112 static int trace_fd = -1;
4113 static off_t trace_frames_offset;
4114 static off_t cur_offset;
4115 static int cur_data_size;
4116 int trace_regblock_size;
4117
4118 static void tfile_interp_line (char *line,
4119 struct uploaded_tp **utpp,
4120 struct uploaded_tsv **utsvp);
4121
4122 /* Read SIZE bytes into READBUF from the trace frame, starting at
4123 TRACE_FD's current position. Note that this call `read'
4124 underneath, hence it advances the file's seek position. Throws an
4125 error if the `read' syscall fails, or less than SIZE bytes are
4126 read. */
4127
4128 static void
4129 tfile_read (gdb_byte *readbuf, int size)
4130 {
4131 int gotten;
4132
4133 gotten = read (trace_fd, readbuf, size);
4134 if (gotten < 0)
4135 perror_with_name (trace_filename);
4136 else if (gotten < size)
4137 error (_("Premature end of file while reading trace file"));
4138 }
4139
4140 static void
4141 tfile_open (char *filename, int from_tty)
4142 {
4143 volatile struct gdb_exception ex;
4144 char *temp;
4145 struct cleanup *old_chain;
4146 int flags;
4147 int scratch_chan;
4148 char header[TRACE_HEADER_SIZE];
4149 char linebuf[1000]; /* Should be max remote packet size or so. */
4150 char byte;
4151 int bytes, i;
4152 struct trace_status *ts;
4153 struct uploaded_tp *uploaded_tps = NULL;
4154 struct uploaded_tsv *uploaded_tsvs = NULL;
4155
4156 target_preopen (from_tty);
4157 if (!filename)
4158 error (_("No trace file specified."));
4159
4160 filename = tilde_expand (filename);
4161 if (!IS_ABSOLUTE_PATH(filename))
4162 {
4163 temp = concat (current_directory, "/", filename, (char *) NULL);
4164 xfree (filename);
4165 filename = temp;
4166 }
4167
4168 old_chain = make_cleanup (xfree, filename);
4169
4170 flags = O_BINARY | O_LARGEFILE;
4171 flags |= O_RDONLY;
4172 scratch_chan = open (filename, flags, 0);
4173 if (scratch_chan < 0)
4174 perror_with_name (filename);
4175
4176 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
4177
4178 discard_cleanups (old_chain); /* Don't free filename any more. */
4179 unpush_target (&tfile_ops);
4180
4181 trace_filename = xstrdup (filename);
4182 trace_fd = scratch_chan;
4183
4184 bytes = 0;
4185 /* Read the file header and test for validity. */
4186 tfile_read ((gdb_byte *) &header, TRACE_HEADER_SIZE);
4187
4188 bytes += TRACE_HEADER_SIZE;
4189 if (!(header[0] == 0x7f
4190 && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
4191 error (_("File is not a valid trace file."));
4192
4193 push_target (&tfile_ops);
4194
4195 trace_regblock_size = 0;
4196 ts = current_trace_status ();
4197 /* We know we're working with a file. Record its name. */
4198 ts->filename = trace_filename;
4199 /* Set defaults in case there is no status line. */
4200 ts->running_known = 0;
4201 ts->stop_reason = trace_stop_reason_unknown;
4202 ts->traceframe_count = -1;
4203 ts->buffer_free = 0;
4204 ts->disconnected_tracing = 0;
4205 ts->circular_buffer = 0;
4206
4207 TRY_CATCH (ex, RETURN_MASK_ALL)
4208 {
4209 /* Read through a section of newline-terminated lines that
4210 define things like tracepoints. */
4211 i = 0;
4212 while (1)
4213 {
4214 tfile_read (&byte, 1);
4215
4216 ++bytes;
4217 if (byte == '\n')
4218 {
4219 /* Empty line marks end of the definition section. */
4220 if (i == 0)
4221 break;
4222 linebuf[i] = '\0';
4223 i = 0;
4224 tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
4225 }
4226 else
4227 linebuf[i++] = byte;
4228 if (i >= 1000)
4229 error (_("Excessively long lines in trace file"));
4230 }
4231
4232 /* Record the starting offset of the binary trace data. */
4233 trace_frames_offset = bytes;
4234
4235 /* If we don't have a blocksize, we can't interpret the
4236 traceframes. */
4237 if (trace_regblock_size == 0)
4238 error (_("No register block size recorded in trace file"));
4239 }
4240 if (ex.reason < 0)
4241 {
4242 /* Pop the partially set up target. */
4243 pop_target ();
4244 throw_exception (ex);
4245 }
4246
4247 inferior_appeared (current_inferior (), TFILE_PID);
4248 inferior_ptid = pid_to_ptid (TFILE_PID);
4249 add_thread_silent (inferior_ptid);
4250
4251 if (ts->traceframe_count <= 0)
4252 warning (_("No traceframes present in this file."));
4253
4254 /* Add the file's tracepoints and variables into the current mix. */
4255
4256 /* Get trace state variables first, they may be checked when parsing
4257 uploaded commands. */
4258 merge_uploaded_trace_state_variables (&uploaded_tsvs);
4259
4260 merge_uploaded_tracepoints (&uploaded_tps);
4261
4262 post_create_inferior (&tfile_ops, from_tty);
4263 }
4264
4265 /* Interpret the given line from the definitions part of the trace
4266 file. */
4267
4268 static void
4269 tfile_interp_line (char *line,
4270 struct uploaded_tp **utpp, struct uploaded_tsv **utsvp)
4271 {
4272 char *p = line;
4273
4274 if (strncmp (p, "R ", strlen ("R ")) == 0)
4275 {
4276 p += strlen ("R ");
4277 trace_regblock_size = strtol (p, &p, 16);
4278 }
4279 else if (strncmp (p, "status ", strlen ("status ")) == 0)
4280 {
4281 p += strlen ("status ");
4282 parse_trace_status (p, current_trace_status ());
4283 }
4284 else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
4285 {
4286 p += strlen ("tp ");
4287 parse_tracepoint_definition (p, utpp);
4288 }
4289 else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
4290 {
4291 p += strlen ("tsv ");
4292 parse_tsv_definition (p, utsvp);
4293 }
4294 else
4295 warning (_("Ignoring trace file definition \"%s\""), line);
4296 }
4297
4298 /* Parse the part of trace status syntax that is shared between
4299 the remote protocol and the trace file reader. */
4300
4301 void
4302 parse_trace_status (char *line, struct trace_status *ts)
4303 {
4304 char *p = line, *p1, *p2, *p3, *p_temp;
4305 int end;
4306 ULONGEST val;
4307
4308 ts->running_known = 1;
4309 ts->running = (*p++ == '1');
4310 ts->stop_reason = trace_stop_reason_unknown;
4311 xfree (ts->stop_desc);
4312 ts->stop_desc = NULL;
4313 ts->traceframe_count = -1;
4314 ts->traceframes_created = -1;
4315 ts->buffer_free = -1;
4316 ts->buffer_size = -1;
4317 ts->disconnected_tracing = 0;
4318 ts->circular_buffer = 0;
4319 xfree (ts->user_name);
4320 ts->user_name = NULL;
4321 xfree (ts->notes);
4322 ts->notes = NULL;
4323 ts->start_time = ts->stop_time = 0;
4324
4325 while (*p++)
4326 {
4327 p1 = strchr (p, ':');
4328 if (p1 == NULL)
4329 error (_("Malformed trace status, at %s\n\
4330 Status line: '%s'\n"), p, line);
4331 p3 = strchr (p, ';');
4332 if (p3 == NULL)
4333 p3 = p + strlen (p);
4334 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
4335 {
4336 p = unpack_varlen_hex (++p1, &val);
4337 ts->stop_reason = trace_buffer_full;
4338 }
4339 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
4340 {
4341 p = unpack_varlen_hex (++p1, &val);
4342 ts->stop_reason = trace_never_run;
4343 }
4344 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
4345 p1 - p) == 0)
4346 {
4347 p = unpack_varlen_hex (++p1, &val);
4348 ts->stop_reason = tracepoint_passcount;
4349 ts->stopping_tracepoint = val;
4350 }
4351 else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
4352 {
4353 p2 = strchr (++p1, ':');
4354 if (!p2 || p2 > p3)
4355 {
4356 /*older style*/
4357 p2 = p1;
4358 }
4359 else if (p2 != p1)
4360 {
4361 ts->stop_desc = xmalloc (strlen (line));
4362 end = hex2bin (p1, ts->stop_desc, (p2 - p1) / 2);
4363 ts->stop_desc[end] = '\0';
4364 }
4365 else
4366 ts->stop_desc = xstrdup ("");
4367
4368 p = unpack_varlen_hex (++p2, &val);
4369 ts->stop_reason = tstop_command;
4370 }
4371 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
4372 {
4373 p = unpack_varlen_hex (++p1, &val);
4374 ts->stop_reason = trace_disconnected;
4375 }
4376 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
4377 {
4378 p2 = strchr (++p1, ':');
4379 if (p2 != p1)
4380 {
4381 ts->stop_desc = xmalloc ((p2 - p1) / 2 + 1);
4382 end = hex2bin (p1, ts->stop_desc, (p2 - p1) / 2);
4383 ts->stop_desc[end] = '\0';
4384 }
4385 else
4386 ts->stop_desc = xstrdup ("");
4387
4388 p = unpack_varlen_hex (++p2, &val);
4389 ts->stopping_tracepoint = val;
4390 ts->stop_reason = tracepoint_error;
4391 }
4392 else if (strncmp (p, "tframes", p1 - p) == 0)
4393 {
4394 p = unpack_varlen_hex (++p1, &val);
4395 ts->traceframe_count = val;
4396 }
4397 else if (strncmp (p, "tcreated", p1 - p) == 0)
4398 {
4399 p = unpack_varlen_hex (++p1, &val);
4400 ts->traceframes_created = val;
4401 }
4402 else if (strncmp (p, "tfree", p1 - p) == 0)
4403 {
4404 p = unpack_varlen_hex (++p1, &val);
4405 ts->buffer_free = val;
4406 }
4407 else if (strncmp (p, "tsize", p1 - p) == 0)
4408 {
4409 p = unpack_varlen_hex (++p1, &val);
4410 ts->buffer_size = val;
4411 }
4412 else if (strncmp (p, "disconn", p1 - p) == 0)
4413 {
4414 p = unpack_varlen_hex (++p1, &val);
4415 ts->disconnected_tracing = val;
4416 }
4417 else if (strncmp (p, "circular", p1 - p) == 0)
4418 {
4419 p = unpack_varlen_hex (++p1, &val);
4420 ts->circular_buffer = val;
4421 }
4422 else if (strncmp (p, "starttime", p1 - p) == 0)
4423 {
4424 p = unpack_varlen_hex (++p1, &val);
4425 ts->start_time = val;
4426 }
4427 else if (strncmp (p, "stoptime", p1 - p) == 0)
4428 {
4429 p = unpack_varlen_hex (++p1, &val);
4430 ts->stop_time = val;
4431 }
4432 else if (strncmp (p, "username", p1 - p) == 0)
4433 {
4434 ++p1;
4435 ts->user_name = xmalloc (strlen (p) / 2);
4436 end = hex2bin (p1, ts->user_name, (p3 - p1) / 2);
4437 ts->user_name[end] = '\0';
4438 p = p3;
4439 }
4440 else if (strncmp (p, "notes", p1 - p) == 0)
4441 {
4442 ++p1;
4443 ts->notes = xmalloc (strlen (p) / 2);
4444 end = hex2bin (p1, ts->notes, (p3 - p1) / 2);
4445 ts->notes[end] = '\0';
4446 p = p3;
4447 }
4448 else
4449 {
4450 /* Silently skip unknown optional info. */
4451 p_temp = strchr (p1 + 1, ';');
4452 if (p_temp)
4453 p = p_temp;
4454 else
4455 /* Must be at the end. */
4456 break;
4457 }
4458 }
4459 }
4460
4461 void
4462 parse_tracepoint_status (char *p, struct breakpoint *bp,
4463 struct uploaded_tp *utp)
4464 {
4465 ULONGEST uval;
4466 struct tracepoint *tp = (struct tracepoint *) bp;
4467
4468 p = unpack_varlen_hex (p, &uval);
4469 if (tp)
4470 tp->base.hit_count += uval;
4471 else
4472 utp->hit_count += uval;
4473 p = unpack_varlen_hex (p + 1, &uval);
4474 if (tp)
4475 tp->traceframe_usage += uval;
4476 else
4477 utp->traceframe_usage += uval;
4478 /* Ignore any extra, allowing for future extensions. */
4479 }
4480
4481 /* Given a line of text defining a part of a tracepoint, parse it into
4482 an "uploaded tracepoint". */
4483
4484 void
4485 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
4486 {
4487 char *p;
4488 char piece;
4489 ULONGEST num, addr, step, pass, orig_size, xlen, start;
4490 int enabled, end;
4491 enum bptype type;
4492 char *cond, *srctype, *buf;
4493 struct uploaded_tp *utp = NULL;
4494
4495 p = line;
4496 /* Both tracepoint and action definitions start with the same number
4497 and address sequence. */
4498 piece = *p++;
4499 p = unpack_varlen_hex (p, &num);
4500 p++; /* skip a colon */
4501 p = unpack_varlen_hex (p, &addr);
4502 p++; /* skip a colon */
4503 if (piece == 'T')
4504 {
4505 enabled = (*p++ == 'E');
4506 p++; /* skip a colon */
4507 p = unpack_varlen_hex (p, &step);
4508 p++; /* skip a colon */
4509 p = unpack_varlen_hex (p, &pass);
4510 type = bp_tracepoint;
4511 cond = NULL;
4512 /* Thumb through optional fields. */
4513 while (*p == ':')
4514 {
4515 p++; /* skip a colon */
4516 if (*p == 'F')
4517 {
4518 type = bp_fast_tracepoint;
4519 p++;
4520 p = unpack_varlen_hex (p, &orig_size);
4521 }
4522 else if (*p == 'S')
4523 {
4524 type = bp_static_tracepoint;
4525 p++;
4526 }
4527 else if (*p == 'X')
4528 {
4529 p++;
4530 p = unpack_varlen_hex (p, &xlen);
4531 p++; /* skip a comma */
4532 cond = (char *) xmalloc (2 * xlen + 1);
4533 strncpy (cond, p, 2 * xlen);
4534 cond[2 * xlen] = '\0';
4535 p += 2 * xlen;
4536 }
4537 else
4538 warning (_("Unrecognized char '%c' in tracepoint "
4539 "definition, skipping rest"), *p);
4540 }
4541 utp = get_uploaded_tp (num, addr, utpp);
4542 utp->type = type;
4543 utp->enabled = enabled;
4544 utp->step = step;
4545 utp->pass = pass;
4546 utp->cond = cond;
4547 }
4548 else if (piece == 'A')
4549 {
4550 utp = get_uploaded_tp (num, addr, utpp);
4551 VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
4552 }
4553 else if (piece == 'S')
4554 {
4555 utp = get_uploaded_tp (num, addr, utpp);
4556 VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
4557 }
4558 else if (piece == 'Z')
4559 {
4560 /* Parse a chunk of source form definition. */
4561 utp = get_uploaded_tp (num, addr, utpp);
4562 srctype = p;
4563 p = strchr (p, ':');
4564 p++; /* skip a colon */
4565 p = unpack_varlen_hex (p, &start);
4566 p++; /* skip a colon */
4567 p = unpack_varlen_hex (p, &xlen);
4568 p++; /* skip a colon */
4569
4570 buf = alloca (strlen (line));
4571
4572 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
4573 buf[end] = '\0';
4574
4575 if (strncmp (srctype, "at:", strlen ("at:")) == 0)
4576 utp->at_string = xstrdup (buf);
4577 else if (strncmp (srctype, "cond:", strlen ("cond:")) == 0)
4578 utp->cond_string = xstrdup (buf);
4579 else if (strncmp (srctype, "cmd:", strlen ("cmd:")) == 0)
4580 VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
4581 }
4582 else if (piece == 'V')
4583 {
4584 utp = get_uploaded_tp (num, addr, utpp);
4585
4586 parse_tracepoint_status (p, NULL, utp);
4587 }
4588 else
4589 {
4590 /* Don't error out, the target might be sending us optional
4591 info that we don't care about. */
4592 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
4593 }
4594 }
4595
4596 /* Convert a textual description of a trace state variable into an
4597 uploaded object. */
4598
4599 void
4600 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
4601 {
4602 char *p, *buf;
4603 ULONGEST num, initval, builtin;
4604 int end;
4605 struct uploaded_tsv *utsv = NULL;
4606
4607 buf = alloca (strlen (line));
4608
4609 p = line;
4610 p = unpack_varlen_hex (p, &num);
4611 p++; /* skip a colon */
4612 p = unpack_varlen_hex (p, &initval);
4613 p++; /* skip a colon */
4614 p = unpack_varlen_hex (p, &builtin);
4615 p++; /* skip a colon */
4616 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
4617 buf[end] = '\0';
4618
4619 utsv = get_uploaded_tsv (num, utsvp);
4620 utsv->initial_value = initval;
4621 utsv->builtin = builtin;
4622 utsv->name = xstrdup (buf);
4623 }
4624
4625 /* Close the trace file and generally clean up. */
4626
4627 static void
4628 tfile_close (int quitting)
4629 {
4630 int pid;
4631
4632 if (trace_fd < 0)
4633 return;
4634
4635 pid = ptid_get_pid (inferior_ptid);
4636 inferior_ptid = null_ptid; /* Avoid confusion from thread stuff. */
4637 exit_inferior_silent (pid);
4638
4639 close (trace_fd);
4640 trace_fd = -1;
4641 xfree (trace_filename);
4642 trace_filename = NULL;
4643 }
4644
4645 static void
4646 tfile_files_info (struct target_ops *t)
4647 {
4648 printf_filtered ("\t`%s'\n", trace_filename);
4649 }
4650
4651 /* The trace status for a file is that tracing can never be run. */
4652
4653 static int
4654 tfile_get_trace_status (struct trace_status *ts)
4655 {
4656 /* Other bits of trace status were collected as part of opening the
4657 trace files, so nothing to do here. */
4658
4659 return -1;
4660 }
4661
4662 static void
4663 tfile_get_tracepoint_status (struct breakpoint *tp, struct uploaded_tp *utp)
4664 {
4665 /* Other bits of trace status were collected as part of opening the
4666 trace files, so nothing to do here. */
4667 }
4668
4669 /* Given the position of a traceframe in the file, figure out what
4670 address the frame was collected at. This would normally be the
4671 value of a collected PC register, but if not available, we
4672 improvise. */
4673
4674 static ULONGEST
4675 tfile_get_traceframe_address (off_t tframe_offset)
4676 {
4677 ULONGEST addr = 0;
4678 short tpnum;
4679 struct tracepoint *tp;
4680 off_t saved_offset = cur_offset;
4681
4682 /* FIXME dig pc out of collected registers. */
4683
4684 /* Fall back to using tracepoint address. */
4685 lseek (trace_fd, tframe_offset, SEEK_SET);
4686 tfile_read ((gdb_byte *) &tpnum, 2);
4687 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
4688 gdbarch_byte_order
4689 (target_gdbarch ()));
4690
4691 tp = get_tracepoint_by_number_on_target (tpnum);
4692 /* FIXME this is a poor heuristic if multiple locations. */
4693 if (tp && tp->base.loc)
4694 addr = tp->base.loc->address;
4695
4696 /* Restore our seek position. */
4697 cur_offset = saved_offset;
4698 lseek (trace_fd, cur_offset, SEEK_SET);
4699 return addr;
4700 }
4701
4702 /* Given a type of search and some parameters, scan the collection of
4703 traceframes in the file looking for a match. When found, return
4704 both the traceframe and tracepoint number, otherwise -1 for
4705 each. */
4706
4707 static int
4708 tfile_trace_find (enum trace_find_type type, int num,
4709 ULONGEST addr1, ULONGEST addr2, int *tpp)
4710 {
4711 short tpnum;
4712 int tfnum = 0, found = 0;
4713 unsigned int data_size;
4714 struct tracepoint *tp;
4715 off_t offset, tframe_offset;
4716 ULONGEST tfaddr;
4717
4718 if (num == -1)
4719 {
4720 if (tpp)
4721 *tpp = -1;
4722 return -1;
4723 }
4724
4725 lseek (trace_fd, trace_frames_offset, SEEK_SET);
4726 offset = trace_frames_offset;
4727 while (1)
4728 {
4729 tframe_offset = offset;
4730 tfile_read ((gdb_byte *) &tpnum, 2);
4731 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
4732 gdbarch_byte_order
4733 (target_gdbarch ()));
4734 offset += 2;
4735 if (tpnum == 0)
4736 break;
4737 tfile_read ((gdb_byte *) &data_size, 4);
4738 data_size = (unsigned int) extract_unsigned_integer
4739 ((gdb_byte *) &data_size, 4,
4740 gdbarch_byte_order (target_gdbarch ()));
4741 offset += 4;
4742
4743 if (type == tfind_number)
4744 {
4745 /* Looking for a specific trace frame. */
4746 if (tfnum == num)
4747 found = 1;
4748 }
4749 else
4750 {
4751 /* Start from the _next_ trace frame. */
4752 if (tfnum > traceframe_number)
4753 {
4754 switch (type)
4755 {
4756 case tfind_pc:
4757 tfaddr = tfile_get_traceframe_address (tframe_offset);
4758 if (tfaddr == addr1)
4759 found = 1;
4760 break;
4761 case tfind_tp:
4762 tp = get_tracepoint (num);
4763 if (tp && tpnum == tp->number_on_target)
4764 found = 1;
4765 break;
4766 case tfind_range:
4767 tfaddr = tfile_get_traceframe_address (tframe_offset);
4768 if (addr1 <= tfaddr && tfaddr <= addr2)
4769 found = 1;
4770 break;
4771 case tfind_outside:
4772 tfaddr = tfile_get_traceframe_address (tframe_offset);
4773 if (!(addr1 <= tfaddr && tfaddr <= addr2))
4774 found = 1;
4775 break;
4776 default:
4777 internal_error (__FILE__, __LINE__, _("unknown tfind type"));
4778 }
4779 }
4780 }
4781
4782 if (found)
4783 {
4784 if (tpp)
4785 *tpp = tpnum;
4786 cur_offset = offset;
4787 cur_data_size = data_size;
4788
4789 return tfnum;
4790 }
4791 /* Skip past the traceframe's data. */
4792 lseek (trace_fd, data_size, SEEK_CUR);
4793 offset += data_size;
4794 /* Update our own count of traceframes. */
4795 ++tfnum;
4796 }
4797 /* Did not find what we were looking for. */
4798 if (tpp)
4799 *tpp = -1;
4800 return -1;
4801 }
4802
4803 /* Prototype of the callback passed to tframe_walk_blocks. */
4804 typedef int (*walk_blocks_callback_func) (char blocktype, void *data);
4805
4806 /* Callback for traceframe_walk_blocks, used to find a given block
4807 type in a traceframe. */
4808
4809 static int
4810 match_blocktype (char blocktype, void *data)
4811 {
4812 char *wantedp = data;
4813
4814 if (*wantedp == blocktype)
4815 return 1;
4816
4817 return 0;
4818 }
4819
4820 /* Walk over all traceframe block starting at POS offset from
4821 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4822 unmodified. If CALLBACK returns true, this returns the position in
4823 the traceframe where the block is found, relative to the start of
4824 the traceframe (cur_offset). Returns -1 if no callback call
4825 returned true, indicating that all blocks have been walked. */
4826
4827 static int
4828 traceframe_walk_blocks (walk_blocks_callback_func callback,
4829 int pos, void *data)
4830 {
4831 /* Iterate through a traceframe's blocks, looking for a block of the
4832 requested type. */
4833
4834 lseek (trace_fd, cur_offset + pos, SEEK_SET);
4835 while (pos < cur_data_size)
4836 {
4837 unsigned short mlen;
4838 char block_type;
4839
4840 tfile_read (&block_type, 1);
4841
4842 ++pos;
4843
4844 if ((*callback) (block_type, data))
4845 return pos;
4846
4847 switch (block_type)
4848 {
4849 case 'R':
4850 lseek (trace_fd, cur_offset + pos + trace_regblock_size, SEEK_SET);
4851 pos += trace_regblock_size;
4852 break;
4853 case 'M':
4854 lseek (trace_fd, cur_offset + pos + 8, SEEK_SET);
4855 tfile_read ((gdb_byte *) &mlen, 2);
4856 mlen = (unsigned short)
4857 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
4858 gdbarch_byte_order
4859 (target_gdbarch ()));
4860 lseek (trace_fd, mlen, SEEK_CUR);
4861 pos += (8 + 2 + mlen);
4862 break;
4863 case 'V':
4864 lseek (trace_fd, cur_offset + pos + 4 + 8, SEEK_SET);
4865 pos += (4 + 8);
4866 break;
4867 default:
4868 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4869 block_type, block_type);
4870 break;
4871 }
4872 }
4873
4874 return -1;
4875 }
4876
4877 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4878 position offset of a block of type TYPE_WANTED in the current trace
4879 frame, starting at POS. Returns -1 if no such block was found. */
4880
4881 static int
4882 traceframe_find_block_type (char type_wanted, int pos)
4883 {
4884 return traceframe_walk_blocks (match_blocktype, pos, &type_wanted);
4885 }
4886
4887 /* Look for a block of saved registers in the traceframe, and get the
4888 requested register from it. */
4889
4890 static void
4891 tfile_fetch_registers (struct target_ops *ops,
4892 struct regcache *regcache, int regno)
4893 {
4894 struct gdbarch *gdbarch = get_regcache_arch (regcache);
4895 int offset, regn, regsize, pc_regno;
4896 char *regs;
4897
4898 /* An uninitialized reg size says we're not going to be
4899 successful at getting register blocks. */
4900 if (!trace_regblock_size)
4901 return;
4902
4903 regs = alloca (trace_regblock_size);
4904
4905 if (traceframe_find_block_type ('R', 0) >= 0)
4906 {
4907 tfile_read (regs, trace_regblock_size);
4908
4909 /* Assume the block is laid out in GDB register number order,
4910 each register with the size that it has in GDB. */
4911 offset = 0;
4912 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
4913 {
4914 regsize = register_size (gdbarch, regn);
4915 /* Make sure we stay within block bounds. */
4916 if (offset + regsize >= trace_regblock_size)
4917 break;
4918 if (regcache_register_status (regcache, regn) == REG_UNKNOWN)
4919 {
4920 if (regno == regn)
4921 {
4922 regcache_raw_supply (regcache, regno, regs + offset);
4923 break;
4924 }
4925 else if (regno == -1)
4926 {
4927 regcache_raw_supply (regcache, regn, regs + offset);
4928 }
4929 }
4930 offset += regsize;
4931 }
4932 return;
4933 }
4934
4935 /* We get here if no register data has been found. Mark registers
4936 as unavailable. */
4937 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
4938 regcache_raw_supply (regcache, regn, NULL);
4939
4940 /* We can often usefully guess that the PC is going to be the same
4941 as the address of the tracepoint. */
4942 pc_regno = gdbarch_pc_regnum (gdbarch);
4943 if (pc_regno >= 0 && (regno == -1 || regno == pc_regno))
4944 {
4945 struct tracepoint *tp = get_tracepoint (tracepoint_number);
4946
4947 if (tp && tp->base.loc)
4948 {
4949 /* But don't try to guess if tracepoint is multi-location... */
4950 if (tp->base.loc->next)
4951 {
4952 warning (_("Tracepoint %d has multiple "
4953 "locations, cannot infer $pc"),
4954 tp->base.number);
4955 return;
4956 }
4957 /* ... or does while-stepping. */
4958 if (tp->step_count > 0)
4959 {
4960 warning (_("Tracepoint %d does while-stepping, "
4961 "cannot infer $pc"),
4962 tp->base.number);
4963 return;
4964 }
4965
4966 store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
4967 gdbarch_byte_order (gdbarch),
4968 tp->base.loc->address);
4969 regcache_raw_supply (regcache, pc_regno, regs);
4970 }
4971 }
4972 }
4973
4974 static LONGEST
4975 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
4976 const char *annex, gdb_byte *readbuf,
4977 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
4978 {
4979 /* We're only doing regular memory for now. */
4980 if (object != TARGET_OBJECT_MEMORY)
4981 return -1;
4982
4983 if (readbuf == NULL)
4984 error (_("tfile_xfer_partial: trace file is read-only"));
4985
4986 if (traceframe_number != -1)
4987 {
4988 int pos = 0;
4989
4990 /* Iterate through the traceframe's blocks, looking for
4991 memory. */
4992 while ((pos = traceframe_find_block_type ('M', pos)) >= 0)
4993 {
4994 ULONGEST maddr, amt;
4995 unsigned short mlen;
4996 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
4997
4998 tfile_read ((gdb_byte *) &maddr, 8);
4999 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
5000 byte_order);
5001 tfile_read ((gdb_byte *) &mlen, 2);
5002 mlen = (unsigned short)
5003 extract_unsigned_integer ((gdb_byte *) &mlen, 2, byte_order);
5004
5005 /* If the block includes the first part of the desired
5006 range, return as much it has; GDB will re-request the
5007 remainder, which might be in a different block of this
5008 trace frame. */
5009 if (maddr <= offset && offset < (maddr + mlen))
5010 {
5011 amt = (maddr + mlen) - offset;
5012 if (amt > len)
5013 amt = len;
5014
5015 if (maddr != offset)
5016 lseek (trace_fd, offset - maddr, SEEK_CUR);
5017 tfile_read (readbuf, amt);
5018 return amt;
5019 }
5020
5021 /* Skip over this block. */
5022 pos += (8 + 2 + mlen);
5023 }
5024 }
5025
5026 /* It's unduly pedantic to refuse to look at the executable for
5027 read-only pieces; so do the equivalent of readonly regions aka
5028 QTro packet. */
5029 /* FIXME account for relocation at some point. */
5030 if (exec_bfd)
5031 {
5032 asection *s;
5033 bfd_size_type size;
5034 bfd_vma vma;
5035
5036 for (s = exec_bfd->sections; s; s = s->next)
5037 {
5038 if ((s->flags & SEC_LOAD) == 0
5039 || (s->flags & SEC_READONLY) == 0)
5040 continue;
5041
5042 vma = s->vma;
5043 size = bfd_get_section_size (s);
5044 if (vma <= offset && offset < (vma + size))
5045 {
5046 ULONGEST amt;
5047
5048 amt = (vma + size) - offset;
5049 if (amt > len)
5050 amt = len;
5051
5052 amt = bfd_get_section_contents (exec_bfd, s,
5053 readbuf, offset - vma, amt);
5054 return amt;
5055 }
5056 }
5057 }
5058
5059 /* Indicate failure to find the requested memory block. */
5060 return -1;
5061 }
5062
5063 /* Iterate through the blocks of a trace frame, looking for a 'V'
5064 block with a matching tsv number. */
5065
5066 static int
5067 tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
5068 {
5069 int pos;
5070 int found = 0;
5071
5072 /* Iterate over blocks in current frame and find the last 'V'
5073 block in which tsv number is TSVNUM. In one trace frame, there
5074 may be multiple 'V' blocks created for a given trace variable,
5075 and the last matched 'V' block contains the updated value. */
5076 pos = 0;
5077 while ((pos = traceframe_find_block_type ('V', pos)) >= 0)
5078 {
5079 int vnum;
5080
5081 tfile_read ((gdb_byte *) &vnum, 4);
5082 vnum = (int) extract_signed_integer ((gdb_byte *) &vnum, 4,
5083 gdbarch_byte_order
5084 (target_gdbarch ()));
5085 if (tsvnum == vnum)
5086 {
5087 tfile_read ((gdb_byte *) val, 8);
5088 *val = extract_signed_integer ((gdb_byte *) val, 8,
5089 gdbarch_byte_order
5090 (target_gdbarch ()));
5091 found = 1;
5092 }
5093 pos += (4 + 8);
5094 }
5095
5096 return found;
5097 }
5098
5099 static int
5100 tfile_has_all_memory (struct target_ops *ops)
5101 {
5102 return 1;
5103 }
5104
5105 static int
5106 tfile_has_memory (struct target_ops *ops)
5107 {
5108 return 1;
5109 }
5110
5111 static int
5112 tfile_has_stack (struct target_ops *ops)
5113 {
5114 return traceframe_number != -1;
5115 }
5116
5117 static int
5118 tfile_has_registers (struct target_ops *ops)
5119 {
5120 return traceframe_number != -1;
5121 }
5122
5123 static int
5124 tfile_thread_alive (struct target_ops *ops, ptid_t ptid)
5125 {
5126 return 1;
5127 }
5128
5129 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
5130 object for the tfile target's current traceframe. */
5131
5132 static int
5133 build_traceframe_info (char blocktype, void *data)
5134 {
5135 struct traceframe_info *info = data;
5136
5137 switch (blocktype)
5138 {
5139 case 'M':
5140 {
5141 struct mem_range *r;
5142 ULONGEST maddr;
5143 unsigned short mlen;
5144
5145 tfile_read ((gdb_byte *) &maddr, 8);
5146 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
5147 gdbarch_byte_order
5148 (target_gdbarch ()));
5149 tfile_read ((gdb_byte *) &mlen, 2);
5150 mlen = (unsigned short)
5151 extract_unsigned_integer ((gdb_byte *) &mlen,
5152 2, gdbarch_byte_order
5153 (target_gdbarch ()));
5154
5155 r = VEC_safe_push (mem_range_s, info->memory, NULL);
5156
5157 r->start = maddr;
5158 r->length = mlen;
5159 break;
5160 }
5161 case 'V':
5162 case 'R':
5163 case 'S':
5164 {
5165 break;
5166 }
5167 default:
5168 warning (_("Unhandled trace block type (%d) '%c ' "
5169 "while building trace frame info."),
5170 blocktype, blocktype);
5171 break;
5172 }
5173
5174 return 0;
5175 }
5176
5177 static struct traceframe_info *
5178 tfile_traceframe_info (void)
5179 {
5180 struct traceframe_info *info = XCNEW (struct traceframe_info);
5181
5182 traceframe_walk_blocks (build_traceframe_info, 0, info);
5183 return info;
5184 }
5185
5186 static void
5187 init_tfile_ops (void)
5188 {
5189 tfile_ops.to_shortname = "tfile";
5190 tfile_ops.to_longname = "Local trace dump file";
5191 tfile_ops.to_doc
5192 = "Use a trace file as a target. Specify the filename of the trace file.";
5193 tfile_ops.to_open = tfile_open;
5194 tfile_ops.to_close = tfile_close;
5195 tfile_ops.to_fetch_registers = tfile_fetch_registers;
5196 tfile_ops.to_xfer_partial = tfile_xfer_partial;
5197 tfile_ops.to_files_info = tfile_files_info;
5198 tfile_ops.to_get_trace_status = tfile_get_trace_status;
5199 tfile_ops.to_get_tracepoint_status = tfile_get_tracepoint_status;
5200 tfile_ops.to_trace_find = tfile_trace_find;
5201 tfile_ops.to_get_trace_state_variable_value
5202 = tfile_get_trace_state_variable_value;
5203 tfile_ops.to_stratum = process_stratum;
5204 tfile_ops.to_has_all_memory = tfile_has_all_memory;
5205 tfile_ops.to_has_memory = tfile_has_memory;
5206 tfile_ops.to_has_stack = tfile_has_stack;
5207 tfile_ops.to_has_registers = tfile_has_registers;
5208 tfile_ops.to_traceframe_info = tfile_traceframe_info;
5209 tfile_ops.to_thread_alive = tfile_thread_alive;
5210 tfile_ops.to_magic = OPS_MAGIC;
5211 }
5212
5213 void
5214 free_current_marker (void *arg)
5215 {
5216 struct static_tracepoint_marker **marker_p = arg;
5217
5218 if (*marker_p != NULL)
5219 {
5220 release_static_tracepoint_marker (*marker_p);
5221 xfree (*marker_p);
5222 }
5223 else
5224 *marker_p = NULL;
5225 }
5226
5227 /* Given a line of text defining a static tracepoint marker, parse it
5228 into a "static tracepoint marker" object. Throws an error is
5229 parsing fails. If PP is non-null, it points to one past the end of
5230 the parsed marker definition. */
5231
5232 void
5233 parse_static_tracepoint_marker_definition (char *line, char **pp,
5234 struct static_tracepoint_marker *marker)
5235 {
5236 char *p, *endp;
5237 ULONGEST addr;
5238 int end;
5239
5240 p = line;
5241 p = unpack_varlen_hex (p, &addr);
5242 p++; /* skip a colon */
5243
5244 marker->gdbarch = target_gdbarch ();
5245 marker->address = (CORE_ADDR) addr;
5246
5247 endp = strchr (p, ':');
5248 if (endp == NULL)
5249 error (_("bad marker definition: %s"), line);
5250
5251 marker->str_id = xmalloc (endp - p + 1);
5252 end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
5253 marker->str_id[end] = '\0';
5254
5255 p += 2 * end;
5256 p++; /* skip a colon */
5257
5258 marker->extra = xmalloc (strlen (p) + 1);
5259 end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
5260 marker->extra[end] = '\0';
5261
5262 if (pp)
5263 *pp = p;
5264 }
5265
5266 /* Release a static tracepoint marker's contents. Note that the
5267 object itself isn't released here. There objects are usually on
5268 the stack. */
5269
5270 void
5271 release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
5272 {
5273 xfree (marker->str_id);
5274 marker->str_id = NULL;
5275 }
5276
5277 /* Print MARKER to gdb_stdout. */
5278
5279 static void
5280 print_one_static_tracepoint_marker (int count,
5281 struct static_tracepoint_marker *marker)
5282 {
5283 struct command_line *l;
5284 struct symbol *sym;
5285
5286 char wrap_indent[80];
5287 char extra_field_indent[80];
5288 struct ui_out *uiout = current_uiout;
5289 struct cleanup *bkpt_chain;
5290 VEC(breakpoint_p) *tracepoints;
5291
5292 struct symtab_and_line sal;
5293
5294 init_sal (&sal);
5295
5296 sal.pc = marker->address;
5297
5298 tracepoints = static_tracepoints_here (marker->address);
5299
5300 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "marker");
5301
5302 /* A counter field to help readability. This is not a stable
5303 identifier! */
5304 ui_out_field_int (uiout, "count", count);
5305
5306 ui_out_field_string (uiout, "marker-id", marker->str_id);
5307
5308 ui_out_field_fmt (uiout, "enabled", "%c",
5309 !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
5310 ui_out_spaces (uiout, 2);
5311
5312 strcpy (wrap_indent, " ");
5313
5314 if (gdbarch_addr_bit (marker->gdbarch) <= 32)
5315 strcat (wrap_indent, " ");
5316 else
5317 strcat (wrap_indent, " ");
5318
5319 strcpy (extra_field_indent, " ");
5320
5321 ui_out_field_core_addr (uiout, "addr", marker->gdbarch, marker->address);
5322
5323 sal = find_pc_line (marker->address, 0);
5324 sym = find_pc_sect_function (marker->address, NULL);
5325 if (sym)
5326 {
5327 ui_out_text (uiout, "in ");
5328 ui_out_field_string (uiout, "func",
5329 SYMBOL_PRINT_NAME (sym));
5330 ui_out_wrap_hint (uiout, wrap_indent);
5331 ui_out_text (uiout, " at ");
5332 }
5333 else
5334 ui_out_field_skip (uiout, "func");
5335
5336 if (sal.symtab != NULL)
5337 {
5338 ui_out_field_string (uiout, "file",
5339 symtab_to_filename_for_display (sal.symtab));
5340 ui_out_text (uiout, ":");
5341
5342 if (ui_out_is_mi_like_p (uiout))
5343 {
5344 const char *fullname = symtab_to_fullname (sal.symtab);
5345
5346 ui_out_field_string (uiout, "fullname", fullname);
5347 }
5348 else
5349 ui_out_field_skip (uiout, "fullname");
5350
5351 ui_out_field_int (uiout, "line", sal.line);
5352 }
5353 else
5354 {
5355 ui_out_field_skip (uiout, "fullname");
5356 ui_out_field_skip (uiout, "line");
5357 }
5358
5359 ui_out_text (uiout, "\n");
5360 ui_out_text (uiout, extra_field_indent);
5361 ui_out_text (uiout, _("Data: \""));
5362 ui_out_field_string (uiout, "extra-data", marker->extra);
5363 ui_out_text (uiout, "\"\n");
5364
5365 if (!VEC_empty (breakpoint_p, tracepoints))
5366 {
5367 struct cleanup *cleanup_chain;
5368 int ix;
5369 struct breakpoint *b;
5370
5371 cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
5372 "tracepoints-at");
5373
5374 ui_out_text (uiout, extra_field_indent);
5375 ui_out_text (uiout, _("Probed by static tracepoints: "));
5376 for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
5377 {
5378 if (ix > 0)
5379 ui_out_text (uiout, ", ");
5380 ui_out_text (uiout, "#");
5381 ui_out_field_int (uiout, "tracepoint-id", b->number);
5382 }
5383
5384 do_cleanups (cleanup_chain);
5385
5386 if (ui_out_is_mi_like_p (uiout))
5387 ui_out_field_int (uiout, "number-of-tracepoints",
5388 VEC_length(breakpoint_p, tracepoints));
5389 else
5390 ui_out_text (uiout, "\n");
5391 }
5392 VEC_free (breakpoint_p, tracepoints);
5393
5394 do_cleanups (bkpt_chain);
5395 }
5396
5397 static void
5398 info_static_tracepoint_markers_command (char *arg, int from_tty)
5399 {
5400 VEC(static_tracepoint_marker_p) *markers;
5401 struct cleanup *old_chain;
5402 struct static_tracepoint_marker *marker;
5403 struct ui_out *uiout = current_uiout;
5404 int i;
5405
5406 /* We don't have to check target_can_use_agent and agent's capability on
5407 static tracepoint here, in order to be compatible with older GDBserver.
5408 We don't check USE_AGENT is true or not, because static tracepoints
5409 don't work without in-process agent, so we don't bother users to type
5410 `set agent on' when to use static tracepoint. */
5411
5412 old_chain
5413 = make_cleanup_ui_out_table_begin_end (uiout, 5, -1,
5414 "StaticTracepointMarkersTable");
5415
5416 ui_out_table_header (uiout, 7, ui_left, "counter", "Cnt");
5417
5418 ui_out_table_header (uiout, 40, ui_left, "marker-id", "ID");
5419
5420 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
5421 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
5422 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");
5423 else
5424 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
5425 ui_out_table_header (uiout, 40, ui_noalign, "what", "What");
5426
5427 ui_out_table_body (uiout);
5428
5429 markers = target_static_tracepoint_markers_by_strid (NULL);
5430 make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
5431
5432 for (i = 0;
5433 VEC_iterate (static_tracepoint_marker_p,
5434 markers, i, marker);
5435 i++)
5436 {
5437 print_one_static_tracepoint_marker (i + 1, marker);
5438 release_static_tracepoint_marker (marker);
5439 }
5440
5441 do_cleanups (old_chain);
5442 }
5443
5444 /* The $_sdata convenience variable is a bit special. We don't know
5445 for sure type of the value until we actually have a chance to fetch
5446 the data --- the size of the object depends on what has been
5447 collected. We solve this by making $_sdata be an internalvar that
5448 creates a new value on access. */
5449
5450 /* Return a new value with the correct type for the sdata object of
5451 the current trace frame. Return a void value if there's no object
5452 available. */
5453
5454 static struct value *
5455 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var,
5456 void *ignore)
5457 {
5458 LONGEST size;
5459 gdb_byte *buf;
5460
5461 /* We need to read the whole object before we know its size. */
5462 size = target_read_alloc (&current_target,
5463 TARGET_OBJECT_STATIC_TRACE_DATA,
5464 NULL, &buf);
5465 if (size >= 0)
5466 {
5467 struct value *v;
5468 struct type *type;
5469
5470 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
5471 size);
5472 v = allocate_value (type);
5473 memcpy (value_contents_raw (v), buf, size);
5474 xfree (buf);
5475 return v;
5476 }
5477 else
5478 return allocate_value (builtin_type (gdbarch)->builtin_void);
5479 }
5480
5481 #if !defined(HAVE_LIBEXPAT)
5482
5483 struct traceframe_info *
5484 parse_traceframe_info (const char *tframe_info)
5485 {
5486 static int have_warned;
5487
5488 if (!have_warned)
5489 {
5490 have_warned = 1;
5491 warning (_("Can not parse XML trace frame info; XML support "
5492 "was disabled at compile time"));
5493 }
5494
5495 return NULL;
5496 }
5497
5498 #else /* HAVE_LIBEXPAT */
5499
5500 #include "xml-support.h"
5501
5502 /* Handle the start of a <memory> element. */
5503
5504 static void
5505 traceframe_info_start_memory (struct gdb_xml_parser *parser,
5506 const struct gdb_xml_element *element,
5507 void *user_data, VEC(gdb_xml_value_s) *attributes)
5508 {
5509 struct traceframe_info *info = user_data;
5510 struct mem_range *r = VEC_safe_push (mem_range_s, info->memory, NULL);
5511 ULONGEST *start_p, *length_p;
5512
5513 start_p = xml_find_attribute (attributes, "start")->value;
5514 length_p = xml_find_attribute (attributes, "length")->value;
5515
5516 r->start = *start_p;
5517 r->length = *length_p;
5518 }
5519
5520 /* Discard the constructed trace frame info (if an error occurs). */
5521
5522 static void
5523 free_result (void *p)
5524 {
5525 struct traceframe_info *result = p;
5526
5527 free_traceframe_info (result);
5528 }
5529
5530 /* The allowed elements and attributes for an XML memory map. */
5531
5532 static const struct gdb_xml_attribute memory_attributes[] = {
5533 { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
5534 { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
5535 { NULL, GDB_XML_AF_NONE, NULL, NULL }
5536 };
5537
5538 static const struct gdb_xml_element traceframe_info_children[] = {
5539 { "memory", memory_attributes, NULL,
5540 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
5541 traceframe_info_start_memory, NULL },
5542 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
5543 };
5544
5545 static const struct gdb_xml_element traceframe_info_elements[] = {
5546 { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
5547 NULL, NULL },
5548 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
5549 };
5550
5551 /* Parse a traceframe-info XML document. */
5552
5553 struct traceframe_info *
5554 parse_traceframe_info (const char *tframe_info)
5555 {
5556 struct traceframe_info *result;
5557 struct cleanup *back_to;
5558
5559 result = XCNEW (struct traceframe_info);
5560 back_to = make_cleanup (free_result, result);
5561
5562 if (gdb_xml_parse_quick (_("trace frame info"),
5563 "traceframe-info.dtd", traceframe_info_elements,
5564 tframe_info, result) == 0)
5565 {
5566 /* Parsed successfully, keep the result. */
5567 discard_cleanups (back_to);
5568
5569 return result;
5570 }
5571
5572 do_cleanups (back_to);
5573 return NULL;
5574 }
5575
5576 #endif /* HAVE_LIBEXPAT */
5577
5578 /* Returns the traceframe_info object for the current traceframe.
5579 This is where we avoid re-fetching the object from the target if we
5580 already have it cached. */
5581
5582 static struct traceframe_info *
5583 get_traceframe_info (void)
5584 {
5585 if (traceframe_info == NULL)
5586 traceframe_info = target_traceframe_info ();
5587
5588 return traceframe_info;
5589 }
5590
5591 /* If the target supports the query, return in RESULT the set of
5592 collected memory in the current traceframe, found within the LEN
5593 bytes range starting at MEMADDR. Returns true if the target
5594 supports the query, otherwise returns false, and RESULT is left
5595 undefined. */
5596
5597 int
5598 traceframe_available_memory (VEC(mem_range_s) **result,
5599 CORE_ADDR memaddr, ULONGEST len)
5600 {
5601 struct traceframe_info *info = get_traceframe_info ();
5602
5603 if (info != NULL)
5604 {
5605 struct mem_range *r;
5606 int i;
5607
5608 *result = NULL;
5609
5610 for (i = 0; VEC_iterate (mem_range_s, info->memory, i, r); i++)
5611 if (mem_ranges_overlap (r->start, r->length, memaddr, len))
5612 {
5613 ULONGEST lo1, hi1, lo2, hi2;
5614 struct mem_range *nr;
5615
5616 lo1 = memaddr;
5617 hi1 = memaddr + len;
5618
5619 lo2 = r->start;
5620 hi2 = r->start + r->length;
5621
5622 nr = VEC_safe_push (mem_range_s, *result, NULL);
5623
5624 nr->start = max (lo1, lo2);
5625 nr->length = min (hi1, hi2) - nr->start;
5626 }
5627
5628 normalize_mem_ranges (*result);
5629 return 1;
5630 }
5631
5632 return 0;
5633 }
5634
5635 /* Implementation of `sdata' variable. */
5636
5637 static const struct internalvar_funcs sdata_funcs =
5638 {
5639 sdata_make_value,
5640 NULL,
5641 NULL
5642 };
5643
5644 /* module initialization */
5645 void
5646 _initialize_tracepoint (void)
5647 {
5648 struct cmd_list_element *c;
5649
5650 /* Explicitly create without lookup, since that tries to create a
5651 value with a void typed value, and when we get here, gdbarch
5652 isn't initialized yet. At this point, we're quite sure there
5653 isn't another convenience variable of the same name. */
5654 create_internalvar_type_lazy ("_sdata", &sdata_funcs, NULL);
5655
5656 traceframe_number = -1;
5657 tracepoint_number = -1;
5658
5659 if (tracepoint_list.list == NULL)
5660 {
5661 tracepoint_list.listsize = 128;
5662 tracepoint_list.list = xmalloc
5663 (tracepoint_list.listsize * sizeof (struct memrange));
5664 }
5665 if (tracepoint_list.aexpr_list == NULL)
5666 {
5667 tracepoint_list.aexpr_listsize = 128;
5668 tracepoint_list.aexpr_list = xmalloc
5669 (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
5670 }
5671
5672 if (stepping_list.list == NULL)
5673 {
5674 stepping_list.listsize = 128;
5675 stepping_list.list = xmalloc
5676 (stepping_list.listsize * sizeof (struct memrange));
5677 }
5678
5679 if (stepping_list.aexpr_list == NULL)
5680 {
5681 stepping_list.aexpr_listsize = 128;
5682 stepping_list.aexpr_list = xmalloc
5683 (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
5684 }
5685
5686 add_info ("scope", scope_info,
5687 _("List the variables local to a scope"));
5688
5689 add_cmd ("tracepoints", class_trace, NULL,
5690 _("Tracing of program execution without stopping the program."),
5691 &cmdlist);
5692
5693 add_com ("tdump", class_trace, trace_dump_command,
5694 _("Print everything collected at the current tracepoint."));
5695
5696 add_com ("tsave", class_trace, trace_save_command, _("\
5697 Save the trace data to a file.\n\
5698 Use the '-ctf' option to save the data to CTF format.\n\
5699 Use the '-r' option to direct the target to save directly to the file,\n\
5700 using its own filesystem."));
5701
5702 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
5703 Define a trace state variable.\n\
5704 Argument is a $-prefixed name, optionally followed\n\
5705 by '=' and an expression that sets the initial value\n\
5706 at the start of tracing."));
5707 set_cmd_completer (c, expression_completer);
5708
5709 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
5710 Delete one or more trace state variables.\n\
5711 Arguments are the names of the variables to delete.\n\
5712 If no arguments are supplied, delete all variables."), &deletelist);
5713 /* FIXME add a trace variable completer. */
5714
5715 add_info ("tvariables", tvariables_info, _("\
5716 Status of trace state variables and their values.\n\
5717 "));
5718
5719 add_info ("static-tracepoint-markers",
5720 info_static_tracepoint_markers_command, _("\
5721 List target static tracepoints markers.\n\
5722 "));
5723
5724 add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
5725 Select a trace frame;\n\
5726 No argument means forward by one frame; '-' means backward by one frame."),
5727 &tfindlist, "tfind ", 1, &cmdlist);
5728
5729 add_cmd ("outside", class_trace, trace_find_outside_command, _("\
5730 Select a trace frame whose PC is outside the given range (exclusive).\n\
5731 Usage: tfind outside addr1, addr2"),
5732 &tfindlist);
5733
5734 add_cmd ("range", class_trace, trace_find_range_command, _("\
5735 Select a trace frame whose PC is in the given range (inclusive).\n\
5736 Usage: tfind range addr1,addr2"),
5737 &tfindlist);
5738
5739 add_cmd ("line", class_trace, trace_find_line_command, _("\
5740 Select a trace frame by source line.\n\
5741 Argument can be a line number (with optional source file),\n\
5742 a function name, or '*' followed by an address.\n\
5743 Default argument is 'the next source line that was traced'."),
5744 &tfindlist);
5745
5746 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
5747 Select a trace frame by tracepoint number.\n\
5748 Default is the tracepoint for the current trace frame."),
5749 &tfindlist);
5750
5751 add_cmd ("pc", class_trace, trace_find_pc_command, _("\
5752 Select a trace frame by PC.\n\
5753 Default is the current PC, or the PC of the current trace frame."),
5754 &tfindlist);
5755
5756 add_cmd ("end", class_trace, trace_find_end_command, _("\
5757 De-select any trace frame and resume 'live' debugging."),
5758 &tfindlist);
5759
5760 add_alias_cmd ("none", "end", class_trace, 0, &tfindlist);
5761
5762 add_cmd ("start", class_trace, trace_find_start_command,
5763 _("Select the first trace frame in the trace buffer."),
5764 &tfindlist);
5765
5766 add_com ("tstatus", class_trace, trace_status_command,
5767 _("Display the status of the current trace data collection."));
5768
5769 add_com ("tstop", class_trace, trace_stop_command, _("\
5770 Stop trace data collection.\n\
5771 Usage: tstop [ <notes> ... ]\n\
5772 Any arguments supplied are recorded with the trace as a stop reason and\n\
5773 reported by tstatus (if the target supports trace notes)."));
5774
5775 add_com ("tstart", class_trace, trace_start_command, _("\
5776 Start trace data collection.\n\
5777 Usage: tstart [ <notes> ... ]\n\
5778 Any arguments supplied are recorded with the trace as a note and\n\
5779 reported by tstatus (if the target supports trace notes)."));
5780
5781 add_com ("end", class_trace, end_actions_pseudocommand, _("\
5782 Ends a list of commands or actions.\n\
5783 Several GDB commands allow you to enter a list of commands or actions.\n\
5784 Entering \"end\" on a line by itself is the normal way to terminate\n\
5785 such a list.\n\n\
5786 Note: the \"end\" command cannot be used at the gdb prompt."));
5787
5788 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
5789 Specify single-stepping behavior at a tracepoint.\n\
5790 Argument is number of instructions to trace in single-step mode\n\
5791 following the tracepoint. This command is normally followed by\n\
5792 one or more \"collect\" commands, to specify what to collect\n\
5793 while single-stepping.\n\n\
5794 Note: this command can only be used in a tracepoint \"actions\" list."));
5795
5796 add_com_alias ("ws", "while-stepping", class_alias, 0);
5797 add_com_alias ("stepping", "while-stepping", class_alias, 0);
5798
5799 add_com ("collect", class_trace, collect_pseudocommand, _("\
5800 Specify one or more data items to be collected at a tracepoint.\n\
5801 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5802 collect all data (variables, registers) referenced by that expression.\n\
5803 Also accepts the following special arguments:\n\
5804 $regs -- all registers.\n\
5805 $args -- all function arguments.\n\
5806 $locals -- all variables local to the block/function scope.\n\
5807 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5808 Note: this command can only be used in a tracepoint \"actions\" list."));
5809
5810 add_com ("teval", class_trace, teval_pseudocommand, _("\
5811 Specify one or more expressions to be evaluated at a tracepoint.\n\
5812 Accepts a comma-separated list of (one or more) expressions.\n\
5813 The result of each evaluation will be discarded.\n\
5814 Note: this command can only be used in a tracepoint \"actions\" list."));
5815
5816 add_com ("actions", class_trace, trace_actions_command, _("\
5817 Specify the actions to be taken at a tracepoint.\n\
5818 Tracepoint actions may include collecting of specified data,\n\
5819 single-stepping, or enabling/disabling other tracepoints,\n\
5820 depending on target's capabilities."));
5821
5822 default_collect = xstrdup ("");
5823 add_setshow_string_cmd ("default-collect", class_trace,
5824 &default_collect, _("\
5825 Set the list of expressions to collect by default"), _("\
5826 Show the list of expressions to collect by default"), NULL,
5827 NULL, NULL,
5828 &setlist, &showlist);
5829
5830 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
5831 &disconnected_tracing, _("\
5832 Set whether tracing continues after GDB disconnects."), _("\
5833 Show whether tracing continues after GDB disconnects."), _("\
5834 Use this to continue a tracing run even if GDB disconnects\n\
5835 or detaches from the target. You can reconnect later and look at\n\
5836 trace data collected in the meantime."),
5837 set_disconnected_tracing,
5838 NULL,
5839 &setlist,
5840 &showlist);
5841
5842 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
5843 &circular_trace_buffer, _("\
5844 Set target's use of circular trace buffer."), _("\
5845 Show target's use of circular trace buffer."), _("\
5846 Use this to make the trace buffer into a circular buffer,\n\
5847 which will discard traceframes (oldest first) instead of filling\n\
5848 up and stopping the trace run."),
5849 set_circular_trace_buffer,
5850 NULL,
5851 &setlist,
5852 &showlist);
5853
5854 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class,
5855 &trace_buffer_size, _("\
5856 Set requested size of trace buffer."), _("\
5857 Show requested size of trace buffer."), _("\
5858 Use this to choose a size for the trace buffer. Some targets\n\
5859 may have fixed or limited buffer sizes. A value of -1 disables\n\
5860 any attempt to set the buffer size and lets the target choose."),
5861 set_trace_buffer_size, NULL,
5862 &setlist, &showlist);
5863
5864 add_setshow_string_cmd ("trace-user", class_trace,
5865 &trace_user, _("\
5866 Set the user name to use for current and future trace runs"), _("\
5867 Show the user name to use for current and future trace runs"), NULL,
5868 set_trace_user, NULL,
5869 &setlist, &showlist);
5870
5871 add_setshow_string_cmd ("trace-notes", class_trace,
5872 &trace_notes, _("\
5873 Set notes string to use for current and future trace runs"), _("\
5874 Show the notes string to use for current and future trace runs"), NULL,
5875 set_trace_notes, NULL,
5876 &setlist, &showlist);
5877
5878 add_setshow_string_cmd ("trace-stop-notes", class_trace,
5879 &trace_stop_notes, _("\
5880 Set notes string to use for future tstop commands"), _("\
5881 Show the notes string to use for future tstop commands"), NULL,
5882 set_trace_stop_notes, NULL,
5883 &setlist, &showlist);
5884
5885 init_tfile_ops ();
5886
5887 add_target (&tfile_ops);
5888 }