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