2010-03-18 Stan Shebs <stan@codesourcery.com>
[binutils-gdb.git] / gdb / tracepoint.c
1 /* Tracing functionality for remote targets in custom GDB protocol
2
3 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
4 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
5
6 This file is part of GDB.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20
21 #include "defs.h"
22 #include "arch-utils.h"
23 #include "symtab.h"
24 #include "frame.h"
25 #include "gdbtypes.h"
26 #include "expression.h"
27 #include "gdbcmd.h"
28 #include "value.h"
29 #include "target.h"
30 #include "language.h"
31 #include "gdb_string.h"
32 #include "inferior.h"
33 #include "breakpoint.h"
34 #include "tracepoint.h"
35 #include "linespec.h"
36 #include "regcache.h"
37 #include "completer.h"
38 #include "block.h"
39 #include "dictionary.h"
40 #include "observer.h"
41 #include "user-regs.h"
42 #include "valprint.h"
43 #include "gdbcore.h"
44 #include "objfiles.h"
45 #include "filenames.h"
46 #include "gdbthread.h"
47
48 #include "ax.h"
49 #include "ax-gdb.h"
50
51 /* readline include files */
52 #include "readline/readline.h"
53 #include "readline/history.h"
54
55 /* readline defines this. */
56 #undef savestring
57
58 #ifdef HAVE_UNISTD_H
59 #include <unistd.h>
60 #endif
61
62 #ifndef O_LARGEFILE
63 #define O_LARGEFILE 0
64 #endif
65
66 extern int hex2bin (const char *hex, gdb_byte *bin, int count);
67 extern int bin2hex (const gdb_byte *bin, char *hex, int count);
68
69 extern void stop_tracing ();
70
71 /* Maximum length of an agent aexpression.
72 This accounts for the fact that packets are limited to 400 bytes
73 (which includes everything -- including the checksum), and assumes
74 the worst case of maximum length for each of the pieces of a
75 continuation packet.
76
77 NOTE: expressions get mem2hex'ed otherwise this would be twice as
78 large. (400 - 31)/2 == 184 */
79 #define MAX_AGENT_EXPR_LEN 184
80
81 /* A hook used to notify the UI of tracepoint operations. */
82
83 void (*deprecated_trace_find_hook) (char *arg, int from_tty);
84 void (*deprecated_trace_start_stop_hook) (int start, int from_tty);
85
86 extern void (*deprecated_readline_begin_hook) (char *, ...);
87 extern char *(*deprecated_readline_hook) (char *);
88 extern void (*deprecated_readline_end_hook) (void);
89
90 /* GDB commands implemented in other modules:
91 */
92
93 extern void output_command (char *, int);
94
95 /*
96 Tracepoint.c:
97
98 This module defines the following debugger commands:
99 trace : set a tracepoint on a function, line, or address.
100 info trace : list all debugger-defined tracepoints.
101 delete trace : delete one or more tracepoints.
102 enable trace : enable one or more tracepoints.
103 disable trace : disable one or more tracepoints.
104 actions : specify actions to be taken at a tracepoint.
105 passcount : specify a pass count for a tracepoint.
106 tstart : start a trace experiment.
107 tstop : stop a trace experiment.
108 tstatus : query the status of a trace experiment.
109 tfind : find a trace frame in the trace buffer.
110 tdump : print everything collected at the current tracepoint.
111 save-tracepoints : write tracepoint setup into a file.
112
113 This module defines the following user-visible debugger variables:
114 $trace_frame : sequence number of trace frame currently being debugged.
115 $trace_line : source line of trace frame currently being debugged.
116 $trace_file : source file of trace frame currently being debugged.
117 $tracepoint : tracepoint number of trace frame currently being debugged.
118 */
119
120
121 /* ======= Important global variables: ======= */
122
123 /* The list of all trace state variables. We don't retain pointers to
124 any of these for any reason - API is by name or number only - so it
125 works to have a vector of objects. */
126
127 typedef struct trace_state_variable tsv_s;
128 DEF_VEC_O(tsv_s);
129
130 static VEC(tsv_s) *tvariables;
131
132 /* The next integer to assign to a variable. */
133
134 static int next_tsv_number = 1;
135
136 /* Number of last traceframe collected. */
137 static int traceframe_number;
138
139 /* Tracepoint for last traceframe collected. */
140 static int tracepoint_number;
141
142 /* Symbol for function for last traceframe collected */
143 static struct symbol *traceframe_fun;
144
145 /* Symtab and line for last traceframe collected */
146 static struct symtab_and_line traceframe_sal;
147
148 /* Tracing command lists */
149 static struct cmd_list_element *tfindlist;
150
151 /* List of expressions to collect by default at each tracepoint hit. */
152 char *default_collect = "";
153
154 static int disconnected_tracing;
155
156 /* This variable controls whether we ask the target for a linear or
157 circular trace buffer. */
158
159 static int circular_trace_buffer;
160
161 /* ======= Important command functions: ======= */
162 static void trace_actions_command (char *, int);
163 static void trace_start_command (char *, int);
164 static void trace_stop_command (char *, int);
165 static void trace_status_command (char *, int);
166 static void trace_find_command (char *, int);
167 static void trace_find_pc_command (char *, int);
168 static void trace_find_tracepoint_command (char *, int);
169 static void trace_find_line_command (char *, int);
170 static void trace_find_range_command (char *, int);
171 static void trace_find_outside_command (char *, int);
172 static void trace_dump_command (char *, int);
173
174 /* support routines */
175
176 struct collection_list;
177 static void add_aexpr (struct collection_list *, struct agent_expr *);
178 static char *mem2hex (gdb_byte *, char *, int);
179 static void add_register (struct collection_list *collection,
180 unsigned int regno);
181 static struct cleanup *make_cleanup_free_actions (struct breakpoint *t);
182
183 extern void send_disconnected_tracing_value (int value);
184
185 static void free_uploaded_tps (struct uploaded_tp **utpp);
186 static void free_uploaded_tsvs (struct uploaded_tsv **utsvp);
187
188
189 extern void _initialize_tracepoint (void);
190
191 static struct trace_status trace_status;
192
193 char *stop_reason_names[] = {
194 "tunknown",
195 "tnotrun",
196 "tstop",
197 "tfull",
198 "tdisconnected",
199 "tpasscount"
200 };
201
202 struct trace_status *
203 current_trace_status ()
204 {
205 return &trace_status;
206 }
207
208 /* Set traceframe number to NUM. */
209 static void
210 set_traceframe_num (int num)
211 {
212 traceframe_number = num;
213 set_internalvar_integer (lookup_internalvar ("trace_frame"), num);
214 }
215
216 /* Set tracepoint number to NUM. */
217 static void
218 set_tracepoint_num (int num)
219 {
220 tracepoint_number = num;
221 set_internalvar_integer (lookup_internalvar ("tracepoint"), num);
222 }
223
224 /* Set externally visible debug variables for querying/printing
225 the traceframe context (line, function, file) */
226
227 static void
228 set_traceframe_context (struct frame_info *trace_frame)
229 {
230 CORE_ADDR trace_pc;
231
232 if (trace_frame == NULL) /* Cease debugging any trace buffers. */
233 {
234 traceframe_fun = 0;
235 traceframe_sal.pc = traceframe_sal.line = 0;
236 traceframe_sal.symtab = NULL;
237 clear_internalvar (lookup_internalvar ("trace_func"));
238 clear_internalvar (lookup_internalvar ("trace_file"));
239 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
240 return;
241 }
242
243 /* Save as globals for internal use. */
244 trace_pc = get_frame_pc (trace_frame);
245 traceframe_sal = find_pc_line (trace_pc, 0);
246 traceframe_fun = find_pc_function (trace_pc);
247
248 /* Save linenumber as "$trace_line", a debugger variable visible to
249 users. */
250 set_internalvar_integer (lookup_internalvar ("trace_line"),
251 traceframe_sal.line);
252
253 /* Save func name as "$trace_func", a debugger variable visible to
254 users. */
255 if (traceframe_fun == NULL
256 || SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL)
257 clear_internalvar (lookup_internalvar ("trace_func"));
258 else
259 set_internalvar_string (lookup_internalvar ("trace_func"),
260 SYMBOL_LINKAGE_NAME (traceframe_fun));
261
262 /* Save file name as "$trace_file", a debugger variable visible to
263 users. */
264 if (traceframe_sal.symtab == NULL
265 || traceframe_sal.symtab->filename == NULL)
266 clear_internalvar (lookup_internalvar ("trace_file"));
267 else
268 set_internalvar_string (lookup_internalvar ("trace_file"),
269 traceframe_sal.symtab->filename);
270 }
271
272 /* Create a new trace state variable with the given name. */
273
274 struct trace_state_variable *
275 create_trace_state_variable (const char *name)
276 {
277 struct trace_state_variable tsv;
278
279 memset (&tsv, 0, sizeof (tsv));
280 tsv.name = name;
281 tsv.number = next_tsv_number++;
282 return VEC_safe_push (tsv_s, tvariables, &tsv);
283 }
284
285 /* Look for a trace state variable of the given name. */
286
287 struct trace_state_variable *
288 find_trace_state_variable (const char *name)
289 {
290 struct trace_state_variable *tsv;
291 int ix;
292
293 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
294 if (strcmp (name, tsv->name) == 0)
295 return tsv;
296
297 return NULL;
298 }
299
300 void
301 delete_trace_state_variable (const char *name)
302 {
303 struct trace_state_variable *tsv;
304 int ix;
305
306 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
307 if (strcmp (name, tsv->name) == 0)
308 {
309 VEC_unordered_remove (tsv_s, tvariables, ix);
310 return;
311 }
312
313 warning (_("No trace variable named \"$%s\", not deleting"), name);
314 }
315
316 /* The 'tvariable' command collects a name and optional expression to
317 evaluate into an initial value. */
318
319 void
320 trace_variable_command (char *args, int from_tty)
321 {
322 struct expression *expr;
323 struct cleanup *old_chain;
324 struct internalvar *intvar = NULL;
325 LONGEST initval = 0;
326 struct trace_state_variable *tsv;
327
328 if (!args || !*args)
329 error_no_arg (_("trace state variable name"));
330
331 /* All the possible valid arguments are expressions. */
332 expr = parse_expression (args);
333 old_chain = make_cleanup (free_current_contents, &expr);
334
335 if (expr->nelts == 0)
336 error (_("No expression?"));
337
338 /* Only allow two syntaxes; "$name" and "$name=value". */
339 if (expr->elts[0].opcode == OP_INTERNALVAR)
340 {
341 intvar = expr->elts[1].internalvar;
342 }
343 else if (expr->elts[0].opcode == BINOP_ASSIGN
344 && expr->elts[1].opcode == OP_INTERNALVAR)
345 {
346 intvar = expr->elts[2].internalvar;
347 initval = value_as_long (evaluate_subexpression_type (expr, 4));
348 }
349 else
350 error (_("Syntax must be $NAME [ = EXPR ]"));
351
352 if (!intvar)
353 error (_("No name given"));
354
355 if (strlen (internalvar_name (intvar)) <= 0)
356 error (_("Must supply a non-empty variable name"));
357
358 /* If the variable already exists, just change its initial value. */
359 tsv = find_trace_state_variable (internalvar_name (intvar));
360 if (tsv)
361 {
362 tsv->initial_value = initval;
363 printf_filtered (_("Trace state variable $%s now has initial value %s.\n"),
364 tsv->name, plongest (tsv->initial_value));
365 return;
366 }
367
368 /* Create a new variable. */
369 tsv = create_trace_state_variable (internalvar_name (intvar));
370 tsv->initial_value = initval;
371
372 printf_filtered (_("Trace state variable $%s created, with initial value %s.\n"),
373 tsv->name, plongest (tsv->initial_value));
374
375 do_cleanups (old_chain);
376 }
377
378 void
379 delete_trace_variable_command (char *args, int from_tty)
380 {
381 int i, ix;
382 char **argv;
383 struct cleanup *back_to;
384 struct trace_state_variable *tsv;
385
386 if (args == NULL)
387 {
388 if (query (_("Delete all trace state variables? ")))
389 VEC_free (tsv_s, tvariables);
390 dont_repeat ();
391 return;
392 }
393
394 argv = gdb_buildargv (args);
395 back_to = make_cleanup_freeargv (argv);
396
397 for (i = 0; argv[i] != NULL; i++)
398 {
399 if (*argv[i] == '$')
400 delete_trace_state_variable (argv[i] + 1);
401 else
402 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv[i]);
403 }
404
405 do_cleanups (back_to);
406
407 dont_repeat ();
408 }
409
410 /* List all the trace state variables. */
411
412 static void
413 tvariables_info (char *args, int from_tty)
414 {
415 struct trace_state_variable *tsv;
416 int ix;
417 char *reply;
418 ULONGEST tval;
419
420 if (VEC_length (tsv_s, tvariables) == 0)
421 {
422 printf_filtered (_("No trace state variables.\n"));
423 return;
424 }
425
426 /* Try to acquire values from the target. */
427 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
428 tsv->value_known = target_get_trace_state_variable_value (tsv->number,
429 &(tsv->value));
430
431 printf_filtered (_("Name\t\t Initial\tCurrent\n"));
432
433 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
434 {
435 printf_filtered ("$%s", tsv->name);
436 print_spaces_filtered (17 - strlen (tsv->name), gdb_stdout);
437 printf_filtered ("%s ", plongest (tsv->initial_value));
438 print_spaces_filtered (11 - strlen (plongest (tsv->initial_value)), gdb_stdout);
439 if (tsv->value_known)
440 printf_filtered (" %s", plongest (tsv->value));
441 else if (current_trace_status ()->running || traceframe_number >= 0)
442 /* The value is/was defined, but we don't have it. */
443 printf_filtered (_(" <unknown>"));
444 else
445 /* It is not meaningful to ask about the value. */
446 printf_filtered (_(" <undefined>"));
447 printf_filtered ("\n");
448 }
449 }
450
451 /* ACTIONS functions: */
452
453 /* Prototypes for action-parsing utility commands */
454 static void read_actions (struct breakpoint *);
455
456 /* The three functions:
457 collect_pseudocommand,
458 while_stepping_pseudocommand, and
459 end_actions_pseudocommand
460 are placeholders for "commands" that are actually ONLY to be used
461 within a tracepoint action list. If the actual function is ever called,
462 it means that somebody issued the "command" at the top level,
463 which is always an error. */
464
465 void
466 end_actions_pseudocommand (char *args, int from_tty)
467 {
468 error (_("This command cannot be used at the top level."));
469 }
470
471 void
472 while_stepping_pseudocommand (char *args, int from_tty)
473 {
474 error (_("This command can only be used in a tracepoint actions list."));
475 }
476
477 static void
478 collect_pseudocommand (char *args, int from_tty)
479 {
480 error (_("This command can only be used in a tracepoint actions list."));
481 }
482
483 static void
484 teval_pseudocommand (char *args, int from_tty)
485 {
486 error (_("This command can only be used in a tracepoint actions list."));
487 }
488
489 /* Enter a list of actions for a tracepoint. */
490 static void
491 trace_actions_command (char *args, int from_tty)
492 {
493 struct breakpoint *t;
494 char tmpbuf[128];
495 char *end_msg = "End with a line saying just \"end\".";
496
497 t = get_tracepoint_by_number (&args, 0, 1);
498 if (t)
499 {
500 sprintf (tmpbuf, "Enter actions for tracepoint %d, one per line.",
501 t->number);
502
503 if (from_tty)
504 {
505 if (deprecated_readline_begin_hook)
506 (*deprecated_readline_begin_hook) ("%s %s\n", tmpbuf, end_msg);
507 else if (input_from_terminal_p ())
508 printf_filtered ("%s\n%s\n", tmpbuf, end_msg);
509 }
510
511 free_actions (t);
512 t->step_count = 0; /* read_actions may set this */
513 read_actions (t);
514
515 if (deprecated_readline_end_hook)
516 (*deprecated_readline_end_hook) ();
517 /* tracepoints_changed () */
518 }
519 /* else just return */
520 }
521
522 /* worker function */
523 static void
524 read_actions (struct breakpoint *t)
525 {
526 char *line;
527 char *prompt1 = "> ", *prompt2 = " > ";
528 char *prompt = prompt1;
529 enum actionline_type linetype;
530 extern FILE *instream;
531 struct action_line *next = NULL, *temp;
532 struct cleanup *old_chain;
533
534 /* Control-C quits instantly if typed while in this loop
535 since it should not wait until the user types a newline. */
536 immediate_quit++;
537 /* FIXME: kettenis/20010823: Something is wrong here. In this file
538 STOP_SIGNAL is never defined. So this code has been left out, at
539 least for quite a while now. Replacing STOP_SIGNAL with SIGTSTP
540 leads to compilation failures since the variable job_control
541 isn't declared. Leave this alone for now. */
542 #ifdef STOP_SIGNAL
543 if (job_control)
544 signal (STOP_SIGNAL, handle_stop_sig);
545 #endif
546 old_chain = make_cleanup_free_actions (t);
547 while (1)
548 {
549 /* Make sure that all output has been output. Some machines may
550 let you get away with leaving out some of the gdb_flush, but
551 not all. */
552 wrap_here ("");
553 gdb_flush (gdb_stdout);
554 gdb_flush (gdb_stderr);
555
556 if (deprecated_readline_hook && instream == NULL)
557 line = (*deprecated_readline_hook) (prompt);
558 else if (instream == stdin && ISATTY (instream))
559 {
560 line = gdb_readline_wrapper (prompt);
561 if (line && *line) /* add it to command history */
562 add_history (line);
563 }
564 else
565 line = gdb_readline (0);
566
567 if (!line)
568 {
569 line = xstrdup ("end");
570 printf_filtered ("end\n");
571 }
572
573 linetype = validate_actionline (&line, t);
574 if (linetype == BADLINE)
575 continue; /* already warned -- collect another line */
576
577 temp = xmalloc (sizeof (struct action_line));
578 temp->next = NULL;
579 temp->action = line;
580
581 if (next == NULL) /* first action for this tracepoint? */
582 t->actions = next = temp;
583 else
584 {
585 next->next = temp;
586 next = temp;
587 }
588
589 if (linetype == STEPPING) /* begin "while-stepping" */
590 {
591 if (prompt == prompt2)
592 {
593 warning (_("Already processing 'while-stepping'"));
594 continue;
595 }
596 else
597 prompt = prompt2; /* change prompt for stepping actions */
598 }
599 else if (linetype == END)
600 {
601 if (prompt == prompt2)
602 {
603 prompt = prompt1; /* end of single-stepping actions */
604 }
605 else
606 { /* end of actions */
607 if (t->actions->next == NULL)
608 {
609 /* An "end" all by itself with no other actions
610 means this tracepoint has no actions.
611 Discard empty list. */
612 free_actions (t);
613 }
614 break;
615 }
616 }
617 }
618 #ifdef STOP_SIGNAL
619 if (job_control)
620 signal (STOP_SIGNAL, SIG_DFL);
621 #endif
622 immediate_quit--;
623 discard_cleanups (old_chain);
624 }
625
626 /* worker function */
627 enum actionline_type
628 validate_actionline (char **line, struct breakpoint *t)
629 {
630 struct cmd_list_element *c;
631 struct expression *exp = NULL;
632 struct cleanup *old_chain = NULL;
633 char *p, *tmp_p;
634 struct bp_location *loc;
635
636 /* if EOF is typed, *line is NULL */
637 if (*line == NULL)
638 return END;
639
640 for (p = *line; isspace ((int) *p);)
641 p++;
642
643 /* Symbol lookup etc. */
644 if (*p == '\0') /* empty line: just prompt for another line. */
645 return BADLINE;
646
647 if (*p == '#') /* comment line */
648 return GENERIC;
649
650 c = lookup_cmd (&p, cmdlist, "", -1, 1);
651 if (c == 0)
652 {
653 warning (_("'%s' is not an action that I know, or is ambiguous."),
654 p);
655 return BADLINE;
656 }
657
658 if (cmd_cfunc_eq (c, collect_pseudocommand))
659 {
660 struct agent_expr *aexpr;
661 struct agent_reqs areqs;
662
663 do
664 { /* repeat over a comma-separated list */
665 QUIT; /* allow user to bail out with ^C */
666 while (isspace ((int) *p))
667 p++;
668
669 if (*p == '$') /* look for special pseudo-symbols */
670 {
671 if ((0 == strncasecmp ("reg", p + 1, 3)) ||
672 (0 == strncasecmp ("arg", p + 1, 3)) ||
673 (0 == strncasecmp ("loc", p + 1, 3)))
674 {
675 p = strchr (p, ',');
676 continue;
677 }
678 /* else fall thru, treat p as an expression and parse it! */
679 }
680 tmp_p = p;
681 for (loc = t->loc; loc; loc = loc->next)
682 {
683 p = tmp_p;
684 exp = parse_exp_1 (&p, block_for_pc (loc->address), 1);
685 old_chain = make_cleanup (free_current_contents, &exp);
686
687 if (exp->elts[0].opcode == OP_VAR_VALUE)
688 {
689 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
690 {
691 warning (_("constant %s (value %ld) will not be collected."),
692 SYMBOL_PRINT_NAME (exp->elts[2].symbol),
693 SYMBOL_VALUE (exp->elts[2].symbol));
694 return BADLINE;
695 }
696 else if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_OPTIMIZED_OUT)
697 {
698 warning (_("%s is optimized away and cannot be collected."),
699 SYMBOL_PRINT_NAME (exp->elts[2].symbol));
700 return BADLINE;
701 }
702 }
703
704 /* We have something to collect, make sure that the expr to
705 bytecode translator can handle it and that it's not too
706 long. */
707 aexpr = gen_trace_for_expr (loc->address, exp);
708 make_cleanup_free_agent_expr (aexpr);
709
710 if (aexpr->len > MAX_AGENT_EXPR_LEN)
711 error (_("expression too complicated, try simplifying"));
712
713 ax_reqs (aexpr, &areqs);
714 (void) make_cleanup (xfree, areqs.reg_mask);
715
716 if (areqs.flaw != agent_flaw_none)
717 error (_("malformed expression"));
718
719 if (areqs.min_height < 0)
720 error (_("gdb: Internal error: expression has min height < 0"));
721
722 if (areqs.max_height > 20)
723 error (_("expression too complicated, try simplifying"));
724
725 do_cleanups (old_chain);
726 }
727 }
728 while (p && *p++ == ',');
729 return GENERIC;
730 }
731 else if (cmd_cfunc_eq (c, teval_pseudocommand))
732 {
733 struct agent_expr *aexpr;
734
735 do
736 { /* repeat over a comma-separated list */
737 QUIT; /* allow user to bail out with ^C */
738 while (isspace ((int) *p))
739 p++;
740
741 tmp_p = p;
742 for (loc = t->loc; loc; loc = loc->next)
743 {
744 p = tmp_p;
745 /* Only expressions are allowed for this action. */
746 exp = parse_exp_1 (&p, block_for_pc (loc->address), 1);
747 old_chain = make_cleanup (free_current_contents, &exp);
748
749 /* We have something to evaluate, make sure that the expr to
750 bytecode translator can handle it and that it's not too
751 long. */
752 aexpr = gen_eval_for_expr (loc->address, exp);
753 make_cleanup_free_agent_expr (aexpr);
754
755 if (aexpr->len > MAX_AGENT_EXPR_LEN)
756 error (_("expression too complicated, try simplifying"));
757
758 do_cleanups (old_chain);
759 }
760 }
761 while (p && *p++ == ',');
762 return GENERIC;
763 }
764 else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
765 {
766 char *steparg; /* in case warning is necessary */
767
768 while (isspace ((int) *p))
769 p++;
770 steparg = p;
771
772 if (*p == '\0' ||
773 (t->step_count = strtol (p, &p, 0)) == 0)
774 {
775 warning (_("'%s': bad step-count; command ignored."), *line);
776 return BADLINE;
777 }
778 return STEPPING;
779 }
780 else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
781 return END;
782 else
783 {
784 warning (_("'%s' is not a supported tracepoint action."), *line);
785 return BADLINE;
786 }
787 }
788
789 /* worker function */
790 void
791 free_actions (struct breakpoint *t)
792 {
793 struct action_line *line, *next;
794
795 for (line = t->actions; line; line = next)
796 {
797 next = line->next;
798 if (line->action)
799 xfree (line->action);
800 xfree (line);
801 }
802 t->actions = NULL;
803 }
804
805 static void
806 do_free_actions_cleanup (void *t)
807 {
808 free_actions (t);
809 }
810
811 static struct cleanup *
812 make_cleanup_free_actions (struct breakpoint *t)
813 {
814 return make_cleanup (do_free_actions_cleanup, t);
815 }
816
817 enum {
818 memrange_absolute = -1
819 };
820
821 struct memrange
822 {
823 int type; /* memrange_absolute for absolute memory range,
824 else basereg number */
825 bfd_signed_vma start;
826 bfd_signed_vma end;
827 };
828
829 struct collection_list
830 {
831 unsigned char regs_mask[32]; /* room for up to 256 regs */
832 long listsize;
833 long next_memrange;
834 struct memrange *list;
835 long aexpr_listsize; /* size of array pointed to by expr_list elt */
836 long next_aexpr_elt;
837 struct agent_expr **aexpr_list;
838
839 }
840 tracepoint_list, stepping_list;
841
842 /* MEMRANGE functions: */
843
844 static int memrange_cmp (const void *, const void *);
845
846 /* compare memranges for qsort */
847 static int
848 memrange_cmp (const void *va, const void *vb)
849 {
850 const struct memrange *a = va, *b = vb;
851
852 if (a->type < b->type)
853 return -1;
854 if (a->type > b->type)
855 return 1;
856 if (a->type == memrange_absolute)
857 {
858 if ((bfd_vma) a->start < (bfd_vma) b->start)
859 return -1;
860 if ((bfd_vma) a->start > (bfd_vma) b->start)
861 return 1;
862 }
863 else
864 {
865 if (a->start < b->start)
866 return -1;
867 if (a->start > b->start)
868 return 1;
869 }
870 return 0;
871 }
872
873 /* Sort the memrange list using qsort, and merge adjacent memranges. */
874 static void
875 memrange_sortmerge (struct collection_list *memranges)
876 {
877 int a, b;
878
879 qsort (memranges->list, memranges->next_memrange,
880 sizeof (struct memrange), memrange_cmp);
881 if (memranges->next_memrange > 0)
882 {
883 for (a = 0, b = 1; b < memranges->next_memrange; b++)
884 {
885 if (memranges->list[a].type == memranges->list[b].type &&
886 memranges->list[b].start - memranges->list[a].end <=
887 MAX_REGISTER_SIZE)
888 {
889 /* memrange b starts before memrange a ends; merge them. */
890 if (memranges->list[b].end > memranges->list[a].end)
891 memranges->list[a].end = memranges->list[b].end;
892 continue; /* next b, same a */
893 }
894 a++; /* next a */
895 if (a != b)
896 memcpy (&memranges->list[a], &memranges->list[b],
897 sizeof (struct memrange));
898 }
899 memranges->next_memrange = a + 1;
900 }
901 }
902
903 /* Add a register to a collection list. */
904 static void
905 add_register (struct collection_list *collection, unsigned int regno)
906 {
907 if (info_verbose)
908 printf_filtered ("collect register %d\n", regno);
909 if (regno >= (8 * sizeof (collection->regs_mask)))
910 error (_("Internal: register number %d too large for tracepoint"),
911 regno);
912 collection->regs_mask[regno / 8] |= 1 << (regno % 8);
913 }
914
915 /* Add a memrange to a collection list */
916 static void
917 add_memrange (struct collection_list *memranges,
918 int type, bfd_signed_vma base,
919 unsigned long len)
920 {
921 if (info_verbose)
922 {
923 printf_filtered ("(%d,", type);
924 printf_vma (base);
925 printf_filtered (",%ld)\n", len);
926 }
927
928 /* type: memrange_absolute == memory, other n == basereg */
929 memranges->list[memranges->next_memrange].type = type;
930 /* base: addr if memory, offset if reg relative. */
931 memranges->list[memranges->next_memrange].start = base;
932 /* len: we actually save end (base + len) for convenience */
933 memranges->list[memranges->next_memrange].end = base + len;
934 memranges->next_memrange++;
935 if (memranges->next_memrange >= memranges->listsize)
936 {
937 memranges->listsize *= 2;
938 memranges->list = xrealloc (memranges->list,
939 memranges->listsize);
940 }
941
942 if (type != memrange_absolute) /* Better collect the base register! */
943 add_register (memranges, type);
944 }
945
946 /* Add a symbol to a collection list. */
947 static void
948 collect_symbol (struct collection_list *collect,
949 struct symbol *sym,
950 struct gdbarch *gdbarch,
951 long frame_regno, long frame_offset,
952 CORE_ADDR scope)
953 {
954 unsigned long len;
955 unsigned int reg;
956 bfd_signed_vma offset;
957 int treat_as_expr = 0;
958
959 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
960 switch (SYMBOL_CLASS (sym))
961 {
962 default:
963 printf_filtered ("%s: don't know symbol class %d\n",
964 SYMBOL_PRINT_NAME (sym),
965 SYMBOL_CLASS (sym));
966 break;
967 case LOC_CONST:
968 printf_filtered ("constant %s (value %ld) will not be collected.\n",
969 SYMBOL_PRINT_NAME (sym), SYMBOL_VALUE (sym));
970 break;
971 case LOC_STATIC:
972 offset = SYMBOL_VALUE_ADDRESS (sym);
973 if (info_verbose)
974 {
975 char tmp[40];
976
977 sprintf_vma (tmp, offset);
978 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
979 SYMBOL_PRINT_NAME (sym), len,
980 tmp /* address */);
981 }
982 /* A struct may be a C++ class with static fields, go to general
983 expression handling. */
984 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
985 treat_as_expr = 1;
986 else
987 add_memrange (collect, memrange_absolute, offset, len);
988 break;
989 case LOC_REGISTER:
990 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
991 if (info_verbose)
992 printf_filtered ("LOC_REG[parm] %s: ",
993 SYMBOL_PRINT_NAME (sym));
994 add_register (collect, reg);
995 /* Check for doubles stored in two registers. */
996 /* FIXME: how about larger types stored in 3 or more regs? */
997 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
998 len > register_size (gdbarch, reg))
999 add_register (collect, reg + 1);
1000 break;
1001 case LOC_REF_ARG:
1002 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1003 printf_filtered (" (will not collect %s)\n",
1004 SYMBOL_PRINT_NAME (sym));
1005 break;
1006 case LOC_ARG:
1007 reg = frame_regno;
1008 offset = frame_offset + SYMBOL_VALUE (sym);
1009 if (info_verbose)
1010 {
1011 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1012 SYMBOL_PRINT_NAME (sym), len);
1013 printf_vma (offset);
1014 printf_filtered (" from frame ptr reg %d\n", reg);
1015 }
1016 add_memrange (collect, reg, offset, len);
1017 break;
1018 case LOC_REGPARM_ADDR:
1019 reg = SYMBOL_VALUE (sym);
1020 offset = 0;
1021 if (info_verbose)
1022 {
1023 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1024 SYMBOL_PRINT_NAME (sym), len);
1025 printf_vma (offset);
1026 printf_filtered (" from reg %d\n", reg);
1027 }
1028 add_memrange (collect, reg, offset, len);
1029 break;
1030 case LOC_LOCAL:
1031 reg = frame_regno;
1032 offset = frame_offset + SYMBOL_VALUE (sym);
1033 if (info_verbose)
1034 {
1035 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1036 SYMBOL_PRINT_NAME (sym), len);
1037 printf_vma (offset);
1038 printf_filtered (" from frame ptr reg %d\n", reg);
1039 }
1040 add_memrange (collect, reg, offset, len);
1041 break;
1042 case LOC_UNRESOLVED:
1043 printf_filtered ("Don't know LOC_UNRESOLVED %s\n",
1044 SYMBOL_PRINT_NAME (sym));
1045 break;
1046 case LOC_OPTIMIZED_OUT:
1047 printf_filtered ("%s has been optimized out of existence.\n",
1048 SYMBOL_PRINT_NAME (sym));
1049 break;
1050
1051 case LOC_COMPUTED:
1052 treat_as_expr = 1;
1053 break;
1054 }
1055
1056 /* Expressions are the most general case. */
1057 if (treat_as_expr)
1058 {
1059 struct agent_expr *aexpr;
1060 struct cleanup *old_chain1 = NULL;
1061 struct agent_reqs areqs;
1062
1063 aexpr = gen_trace_for_var (scope, gdbarch, sym);
1064
1065 /* It can happen that the symbol is recorded as a computed
1066 location, but it's been optimized away and doesn't actually
1067 have a location expression. */
1068 if (!aexpr)
1069 {
1070 printf_filtered ("%s has been optimized out of existence.\n",
1071 SYMBOL_PRINT_NAME (sym));
1072 return;
1073 }
1074
1075 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1076
1077 ax_reqs (aexpr, &areqs);
1078 if (areqs.flaw != agent_flaw_none)
1079 error (_("malformed expression"));
1080
1081 if (areqs.min_height < 0)
1082 error (_("gdb: Internal error: expression has min height < 0"));
1083 if (areqs.max_height > 20)
1084 error (_("expression too complicated, try simplifying"));
1085
1086 discard_cleanups (old_chain1);
1087 add_aexpr (collect, aexpr);
1088
1089 /* take care of the registers */
1090 if (areqs.reg_mask_len > 0)
1091 {
1092 int ndx1, ndx2;
1093
1094 for (ndx1 = 0; ndx1 < areqs.reg_mask_len; ndx1++)
1095 {
1096 QUIT; /* allow user to bail out with ^C */
1097 if (areqs.reg_mask[ndx1] != 0)
1098 {
1099 /* assume chars have 8 bits */
1100 for (ndx2 = 0; ndx2 < 8; ndx2++)
1101 if (areqs.reg_mask[ndx1] & (1 << ndx2))
1102 /* it's used -- record it */
1103 add_register (collect, ndx1 * 8 + ndx2);
1104 }
1105 }
1106 }
1107 }
1108 }
1109
1110 /* Add all locals (or args) symbols to collection list */
1111 static void
1112 add_local_symbols (struct collection_list *collect,
1113 struct gdbarch *gdbarch, CORE_ADDR pc,
1114 long frame_regno, long frame_offset, int type)
1115 {
1116 struct symbol *sym;
1117 struct block *block;
1118 struct dict_iterator iter;
1119 int count = 0;
1120
1121 block = block_for_pc (pc);
1122 while (block != 0)
1123 {
1124 QUIT; /* allow user to bail out with ^C */
1125 ALL_BLOCK_SYMBOLS (block, iter, sym)
1126 {
1127 if (SYMBOL_IS_ARGUMENT (sym)
1128 ? type == 'A' /* collecting Arguments */
1129 : type == 'L') /* collecting Locals */
1130 {
1131 count++;
1132 collect_symbol (collect, sym, gdbarch,
1133 frame_regno, frame_offset, pc);
1134 }
1135 }
1136 if (BLOCK_FUNCTION (block))
1137 break;
1138 else
1139 block = BLOCK_SUPERBLOCK (block);
1140 }
1141 if (count == 0)
1142 warning (_("No %s found in scope."),
1143 type == 'L' ? "locals" : "args");
1144 }
1145
1146 /* worker function */
1147 static void
1148 clear_collection_list (struct collection_list *list)
1149 {
1150 int ndx;
1151
1152 list->next_memrange = 0;
1153 for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1154 {
1155 free_agent_expr (list->aexpr_list[ndx]);
1156 list->aexpr_list[ndx] = NULL;
1157 }
1158 list->next_aexpr_elt = 0;
1159 memset (list->regs_mask, 0, sizeof (list->regs_mask));
1160 }
1161
1162 /* reduce a collection list to string form (for gdb protocol) */
1163 static char **
1164 stringify_collection_list (struct collection_list *list, char *string)
1165 {
1166 char temp_buf[2048];
1167 char tmp2[40];
1168 int count;
1169 int ndx = 0;
1170 char *(*str_list)[];
1171 char *end;
1172 long i;
1173
1174 count = 1 + list->next_memrange + list->next_aexpr_elt + 1;
1175 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1176
1177 for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1178 if (list->regs_mask[i] != 0) /* skip leading zeroes in regs_mask */
1179 break;
1180 if (list->regs_mask[i] != 0) /* prepare to send regs_mask to the stub */
1181 {
1182 if (info_verbose)
1183 printf_filtered ("\nCollecting registers (mask): 0x");
1184 end = temp_buf;
1185 *end++ = 'R';
1186 for (; i >= 0; i--)
1187 {
1188 QUIT; /* allow user to bail out with ^C */
1189 if (info_verbose)
1190 printf_filtered ("%02X", list->regs_mask[i]);
1191 sprintf (end, "%02X", list->regs_mask[i]);
1192 end += 2;
1193 }
1194 (*str_list)[ndx] = xstrdup (temp_buf);
1195 ndx++;
1196 }
1197 if (info_verbose)
1198 printf_filtered ("\n");
1199 if (list->next_memrange > 0 && info_verbose)
1200 printf_filtered ("Collecting memranges: \n");
1201 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1202 {
1203 QUIT; /* allow user to bail out with ^C */
1204 sprintf_vma (tmp2, list->list[i].start);
1205 if (info_verbose)
1206 {
1207 printf_filtered ("(%d, %s, %ld)\n",
1208 list->list[i].type,
1209 tmp2,
1210 (long) (list->list[i].end - list->list[i].start));
1211 }
1212 if (count + 27 > MAX_AGENT_EXPR_LEN)
1213 {
1214 (*str_list)[ndx] = savestring (temp_buf, count);
1215 ndx++;
1216 count = 0;
1217 end = temp_buf;
1218 }
1219
1220 {
1221 bfd_signed_vma length = list->list[i].end - list->list[i].start;
1222
1223 /* The "%X" conversion specifier expects an unsigned argument,
1224 so passing -1 (memrange_absolute) to it directly gives you
1225 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1226 Special-case it. */
1227 if (list->list[i].type == memrange_absolute)
1228 sprintf (end, "M-1,%s,%lX", tmp2, (long) length);
1229 else
1230 sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length);
1231 }
1232
1233 count += strlen (end);
1234 end = temp_buf + count;
1235 }
1236
1237 for (i = 0; i < list->next_aexpr_elt; i++)
1238 {
1239 QUIT; /* allow user to bail out with ^C */
1240 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1241 {
1242 (*str_list)[ndx] = savestring (temp_buf, count);
1243 ndx++;
1244 count = 0;
1245 end = temp_buf;
1246 }
1247 sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1248 end += 10; /* 'X' + 8 hex digits + ',' */
1249 count += 10;
1250
1251 end = mem2hex (list->aexpr_list[i]->buf,
1252 end, list->aexpr_list[i]->len);
1253 count += 2 * list->aexpr_list[i]->len;
1254 }
1255
1256 if (count != 0)
1257 {
1258 (*str_list)[ndx] = savestring (temp_buf, count);
1259 ndx++;
1260 count = 0;
1261 end = temp_buf;
1262 }
1263 (*str_list)[ndx] = NULL;
1264
1265 if (ndx == 0)
1266 {
1267 xfree (str_list);
1268 return NULL;
1269 }
1270 else
1271 return *str_list;
1272 }
1273
1274 /* Render all actions into gdb protocol. */
1275 /*static*/ void
1276 encode_actions (struct breakpoint *t, struct bp_location *tloc,
1277 char ***tdp_actions, char ***stepping_actions)
1278 {
1279 static char tdp_buff[2048], step_buff[2048];
1280 char *action_exp;
1281 struct expression *exp = NULL;
1282 struct action_line *action;
1283 int i;
1284 struct value *tempval;
1285 struct collection_list *collect;
1286 struct cmd_list_element *cmd;
1287 struct agent_expr *aexpr;
1288 int frame_reg;
1289 LONGEST frame_offset;
1290 char *default_collect_line = NULL;
1291 struct action_line *default_collect_action = NULL;
1292
1293 clear_collection_list (&tracepoint_list);
1294 clear_collection_list (&stepping_list);
1295 collect = &tracepoint_list;
1296
1297 *tdp_actions = NULL;
1298 *stepping_actions = NULL;
1299
1300 gdbarch_virtual_frame_pointer (t->gdbarch,
1301 tloc->address, &frame_reg, &frame_offset);
1302
1303 action = t->actions;
1304
1305 /* If there are default expressions to collect, make up a collect
1306 action and prepend to the action list to encode. Note that since
1307 validation is per-tracepoint (local var "xyz" might be valid for
1308 one tracepoint and not another, etc), we make up the action on
1309 the fly, and don't cache it. */
1310 if (*default_collect)
1311 {
1312 char *line;
1313 enum actionline_type linetype;
1314
1315 default_collect_line = xmalloc (12 + strlen (default_collect));
1316 sprintf (default_collect_line, "collect %s", default_collect);
1317 line = default_collect_line;
1318 linetype = validate_actionline (&line, t);
1319 if (linetype != BADLINE)
1320 {
1321 default_collect_action = xmalloc (sizeof (struct action_line));
1322 default_collect_action->next = t->actions;
1323 default_collect_action->action = line;
1324 action = default_collect_action;
1325 }
1326 }
1327
1328 for (; action; action = action->next)
1329 {
1330 QUIT; /* allow user to bail out with ^C */
1331 action_exp = action->action;
1332 while (isspace ((int) *action_exp))
1333 action_exp++;
1334
1335 if (*action_exp == '#') /* comment line */
1336 return;
1337
1338 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1339 if (cmd == 0)
1340 error (_("Bad action list item: %s"), action_exp);
1341
1342 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1343 {
1344 do
1345 { /* repeat over a comma-separated list */
1346 QUIT; /* allow user to bail out with ^C */
1347 while (isspace ((int) *action_exp))
1348 action_exp++;
1349
1350 if (0 == strncasecmp ("$reg", action_exp, 4))
1351 {
1352 for (i = 0; i < gdbarch_num_regs (t->gdbarch); i++)
1353 add_register (collect, i);
1354 action_exp = strchr (action_exp, ','); /* more? */
1355 }
1356 else if (0 == strncasecmp ("$arg", action_exp, 4))
1357 {
1358 add_local_symbols (collect,
1359 t->gdbarch,
1360 tloc->address,
1361 frame_reg,
1362 frame_offset,
1363 'A');
1364 action_exp = strchr (action_exp, ','); /* more? */
1365 }
1366 else if (0 == strncasecmp ("$loc", action_exp, 4))
1367 {
1368 add_local_symbols (collect,
1369 t->gdbarch,
1370 tloc->address,
1371 frame_reg,
1372 frame_offset,
1373 'L');
1374 action_exp = strchr (action_exp, ','); /* more? */
1375 }
1376 else
1377 {
1378 unsigned long addr, len;
1379 struct cleanup *old_chain = NULL;
1380 struct cleanup *old_chain1 = NULL;
1381 struct agent_reqs areqs;
1382
1383 exp = parse_exp_1 (&action_exp,
1384 block_for_pc (tloc->address), 1);
1385 old_chain = make_cleanup (free_current_contents, &exp);
1386
1387 switch (exp->elts[0].opcode)
1388 {
1389 case OP_REGISTER:
1390 {
1391 const char *name = &exp->elts[2].string;
1392
1393 i = user_reg_map_name_to_regnum (t->gdbarch,
1394 name, strlen (name));
1395 if (i == -1)
1396 internal_error (__FILE__, __LINE__,
1397 _("Register $%s not available"),
1398 name);
1399 if (info_verbose)
1400 printf_filtered ("OP_REGISTER: ");
1401 add_register (collect, i);
1402 break;
1403 }
1404
1405 case UNOP_MEMVAL:
1406 /* safe because we know it's a simple expression */
1407 tempval = evaluate_expression (exp);
1408 addr = value_address (tempval);
1409 len = TYPE_LENGTH (check_typedef (exp->elts[1].type));
1410 add_memrange (collect, memrange_absolute, addr, len);
1411 break;
1412
1413 case OP_VAR_VALUE:
1414 collect_symbol (collect,
1415 exp->elts[2].symbol,
1416 t->gdbarch,
1417 frame_reg,
1418 frame_offset,
1419 tloc->address);
1420 break;
1421
1422 default: /* full-fledged expression */
1423 aexpr = gen_trace_for_expr (tloc->address, exp);
1424
1425 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1426
1427 ax_reqs (aexpr, &areqs);
1428 if (areqs.flaw != agent_flaw_none)
1429 error (_("malformed expression"));
1430
1431 if (areqs.min_height < 0)
1432 error (_("gdb: Internal error: expression has min height < 0"));
1433 if (areqs.max_height > 20)
1434 error (_("expression too complicated, try simplifying"));
1435
1436 discard_cleanups (old_chain1);
1437 add_aexpr (collect, aexpr);
1438
1439 /* take care of the registers */
1440 if (areqs.reg_mask_len > 0)
1441 {
1442 int ndx1;
1443 int ndx2;
1444
1445 for (ndx1 = 0; ndx1 < areqs.reg_mask_len; ndx1++)
1446 {
1447 QUIT; /* allow user to bail out with ^C */
1448 if (areqs.reg_mask[ndx1] != 0)
1449 {
1450 /* assume chars have 8 bits */
1451 for (ndx2 = 0; ndx2 < 8; ndx2++)
1452 if (areqs.reg_mask[ndx1] & (1 << ndx2))
1453 /* it's used -- record it */
1454 add_register (collect,
1455 ndx1 * 8 + ndx2);
1456 }
1457 }
1458 }
1459 break;
1460 } /* switch */
1461 do_cleanups (old_chain);
1462 } /* do */
1463 }
1464 while (action_exp && *action_exp++ == ',');
1465 } /* if */
1466 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1467 {
1468 do
1469 { /* repeat over a comma-separated list */
1470 QUIT; /* allow user to bail out with ^C */
1471 while (isspace ((int) *action_exp))
1472 action_exp++;
1473
1474 {
1475 unsigned long addr, len;
1476 struct cleanup *old_chain = NULL;
1477 struct cleanup *old_chain1 = NULL;
1478 struct agent_reqs areqs;
1479
1480 exp = parse_exp_1 (&action_exp,
1481 block_for_pc (tloc->address), 1);
1482 old_chain = make_cleanup (free_current_contents, &exp);
1483
1484 aexpr = gen_eval_for_expr (tloc->address, exp);
1485 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1486
1487 ax_reqs (aexpr, &areqs);
1488 if (areqs.flaw != agent_flaw_none)
1489 error (_("malformed expression"));
1490
1491 if (areqs.min_height < 0)
1492 error (_("gdb: Internal error: expression has min height < 0"));
1493 if (areqs.max_height > 20)
1494 error (_("expression too complicated, try simplifying"));
1495
1496 discard_cleanups (old_chain1);
1497 /* Even though we're not officially collecting, add
1498 to the collect list anyway. */
1499 add_aexpr (collect, aexpr);
1500
1501 do_cleanups (old_chain);
1502 } /* do */
1503 }
1504 while (action_exp && *action_exp++ == ',');
1505 } /* if */
1506 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1507 {
1508 collect = &stepping_list;
1509 }
1510 else if (cmd_cfunc_eq (cmd, end_actions_pseudocommand))
1511 {
1512 if (collect == &stepping_list) /* end stepping actions */
1513 collect = &tracepoint_list;
1514 else
1515 break; /* end tracepoint actions */
1516 }
1517 } /* for */
1518 memrange_sortmerge (&tracepoint_list);
1519 memrange_sortmerge (&stepping_list);
1520
1521 *tdp_actions = stringify_collection_list (&tracepoint_list,
1522 tdp_buff);
1523 *stepping_actions = stringify_collection_list (&stepping_list,
1524 step_buff);
1525
1526 xfree (default_collect_line);
1527 xfree (default_collect_action);
1528 }
1529
1530 static void
1531 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
1532 {
1533 if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1534 {
1535 collect->aexpr_list =
1536 xrealloc (collect->aexpr_list,
1537 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
1538 collect->aexpr_listsize *= 2;
1539 }
1540 collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1541 collect->next_aexpr_elt++;
1542 }
1543
1544 /* tstart command:
1545
1546 Tell target to clear any previous trace experiment.
1547 Walk the list of tracepoints, and send them (and their actions)
1548 to the target. If no errors,
1549 Tell target to start a new trace experiment. */
1550
1551 static void
1552 trace_start_command (char *args, int from_tty)
1553 {
1554 char buf[2048];
1555 VEC(breakpoint_p) *tp_vec = NULL;
1556 int ix;
1557 struct breakpoint *t;
1558 struct trace_state_variable *tsv;
1559 int any_downloaded = 0;
1560
1561 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1562
1563 target_trace_init ();
1564
1565 tp_vec = all_tracepoints ();
1566 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1567 {
1568 t->number_on_target = 0;
1569 target_download_tracepoint (t);
1570 t->number_on_target = t->number;
1571 any_downloaded = 1;
1572 }
1573 VEC_free (breakpoint_p, tp_vec);
1574
1575 /* No point in tracing without any tracepoints... */
1576 if (!any_downloaded)
1577 error ("No tracepoints downloaded, not starting trace");
1578
1579 /* Send down all the trace state variables too. */
1580 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1581 {
1582 target_download_trace_state_variable (tsv);
1583 }
1584
1585 /* Tell target to treat text-like sections as transparent. */
1586 target_trace_set_readonly_regions ();
1587 /* Set some mode flags. */
1588 target_set_disconnected_tracing (disconnected_tracing);
1589 target_set_circular_trace_buffer (circular_trace_buffer);
1590
1591 /* Now insert traps and begin collecting data. */
1592 target_trace_start ();
1593
1594 /* Reset our local state. */
1595 set_traceframe_num (-1);
1596 set_tracepoint_num (-1);
1597 set_traceframe_context (NULL);
1598 current_trace_status()->running = 1;
1599 }
1600
1601 /* tstop command */
1602 static void
1603 trace_stop_command (char *args, int from_tty)
1604 {
1605 stop_tracing ();
1606 }
1607
1608 void
1609 stop_tracing ()
1610 {
1611 target_trace_stop ();
1612 /* should change in response to reply? */
1613 current_trace_status ()->running = 0;
1614 }
1615
1616 /* tstatus command */
1617 static void
1618 trace_status_command (char *args, int from_tty)
1619 {
1620 struct trace_status *ts = current_trace_status ();
1621 int status;
1622
1623 status = target_get_trace_status (ts);
1624
1625 if (status == -1)
1626 {
1627 if (ts->from_file)
1628 printf_filtered (_("Using a trace file.\n"));
1629 else
1630 {
1631 printf_filtered (_("Trace can not be run on this target.\n"));
1632 return;
1633 }
1634 }
1635
1636 if (!ts->running_known)
1637 {
1638 printf_filtered (_("Run/stop status is unknown.\n"));
1639 }
1640 else if (ts->running)
1641 {
1642 printf_filtered (_("Trace is running on the target.\n"));
1643 if (disconnected_tracing)
1644 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1645 else
1646 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1647 }
1648 else
1649 {
1650 switch (ts->stop_reason)
1651 {
1652 case trace_never_run:
1653 printf_filtered (_("No trace has been run on the target.\n"));
1654 break;
1655 case tstop_command:
1656 printf_filtered (_("Trace stopped by a tstop command.\n"));
1657 break;
1658 case trace_buffer_full:
1659 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1660 break;
1661 case trace_disconnected:
1662 printf_filtered (_("Trace stopped because of disconnection.\n"));
1663 break;
1664 case tracepoint_passcount:
1665 /* FIXME account for number on target */
1666 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1667 ts->stopping_tracepoint);
1668 break;
1669 case trace_stop_reason_unknown:
1670 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1671 break;
1672 default:
1673 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1674 ts->stop_reason);
1675 break;
1676 }
1677 }
1678
1679 if (ts->traceframes_created >= 0
1680 && ts->traceframe_count != ts->traceframes_created)
1681 {
1682 printf_filtered (_("Buffer contains %d trace frames (of %d created total).\n"),
1683 ts->traceframe_count, ts->traceframes_created);
1684 }
1685 else if (ts->traceframe_count >= 0)
1686 {
1687 printf_filtered (_("Collected %d trace frames.\n"),
1688 ts->traceframe_count);
1689 }
1690
1691 if (ts->buffer_free >= 0)
1692 {
1693 if (ts->buffer_size >= 0)
1694 {
1695 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1696 ts->buffer_free, ts->buffer_size);
1697 if (ts->buffer_size > 0)
1698 printf_filtered (_(" (%d%% full)"),
1699 ((int) ((((long long) (ts->buffer_size
1700 - ts->buffer_free)) * 100)
1701 / ts->buffer_size)));
1702 printf_filtered (_(".\n"));
1703 }
1704 else
1705 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1706 ts->buffer_free);
1707 }
1708
1709 /* Now report on what we're doing with tfind. */
1710 if (traceframe_number >= 0)
1711 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1712 traceframe_number, tracepoint_number);
1713 else
1714 printf_filtered (_("Not looking at any trace frame.\n"));
1715 }
1716
1717 void
1718 disconnect_or_stop_tracing (int from_tty)
1719 {
1720 /* It can happen that the target that was tracing went away on its
1721 own, and we didn't notice. Get a status update, and if the
1722 current target doesn't even do tracing, then assume it's not
1723 running anymore. */
1724 if (target_get_trace_status (current_trace_status ()) < 0)
1725 current_trace_status ()->running = 0;
1726
1727 if (current_trace_status ()->running && from_tty)
1728 {
1729 int cont = query (_("Trace is running. Continue tracing after detach? "));
1730 /* Note that we send the query result without affecting the
1731 user's setting of disconnected_tracing, so that the answer is
1732 a one-time-only. */
1733 send_disconnected_tracing_value (cont);
1734
1735 /* Also ensure that we do the equivalent of a tstop command if
1736 tracing is not to continue after the detach. */
1737 if (!cont)
1738 stop_tracing ();
1739 }
1740 }
1741
1742 /* Worker function for the various flavors of the tfind command. */
1743 static void
1744 finish_tfind_command (enum trace_find_type type, int num,
1745 ULONGEST addr1, ULONGEST addr2,
1746 int from_tty)
1747 {
1748 int target_frameno = -1, target_tracept = -1;
1749 struct frame_id old_frame_id;
1750 char *reply;
1751 struct breakpoint *tp;
1752
1753 old_frame_id = get_frame_id (get_current_frame ());
1754
1755 target_frameno = target_trace_find (type, num, addr1, addr2,
1756 &target_tracept);
1757
1758 if (type == tfind_number
1759 && num == -1
1760 && target_frameno == -1)
1761 {
1762 /* We told the target to get out of tfind mode, and it did. */
1763 }
1764 else if (target_frameno == -1)
1765 {
1766 /* A request for a non-existant trace frame has failed.
1767 Our response will be different, depending on FROM_TTY:
1768
1769 If FROM_TTY is true, meaning that this command was
1770 typed interactively by the user, then give an error
1771 and DO NOT change the state of traceframe_number etc.
1772
1773 However if FROM_TTY is false, meaning that we're either
1774 in a script, a loop, or a user-defined command, then
1775 DON'T give an error, but DO change the state of
1776 traceframe_number etc. to invalid.
1777
1778 The rationalle is that if you typed the command, you
1779 might just have committed a typo or something, and you'd
1780 like to NOT lose your current debugging state. However
1781 if you're in a user-defined command or especially in a
1782 loop, then you need a way to detect that the command
1783 failed WITHOUT aborting. This allows you to write
1784 scripts that search thru the trace buffer until the end,
1785 and then continue on to do something else. */
1786
1787 if (from_tty)
1788 error (_("Target failed to find requested trace frame."));
1789 else
1790 {
1791 if (info_verbose)
1792 printf_filtered ("End of trace buffer.\n");
1793 #if 0 /* dubious now? */
1794 /* The following will not recurse, since it's
1795 special-cased. */
1796 trace_find_command ("-1", from_tty);
1797 #endif
1798 }
1799 }
1800
1801 tp = get_tracepoint_by_number_on_target (target_tracept);
1802
1803 reinit_frame_cache ();
1804 registers_changed ();
1805 target_dcache_invalidate ();
1806 set_traceframe_num (target_frameno);
1807 set_tracepoint_num (tp ? tp->number : target_tracept);
1808 if (target_frameno == -1)
1809 set_traceframe_context (NULL);
1810 else
1811 set_traceframe_context (get_current_frame ());
1812
1813 /* If we're in nonstop mode and getting out of looking at trace
1814 frames, there won't be any current frame to go back to and
1815 display. */
1816 if (from_tty
1817 && (has_stack_frames () || traceframe_number >= 0))
1818 {
1819 enum print_what print_what;
1820
1821 /* NOTE: in immitation of the step command, try to determine
1822 whether we have made a transition from one function to
1823 another. If so, we'll print the "stack frame" (ie. the new
1824 function and it's arguments) -- otherwise we'll just show the
1825 new source line. */
1826
1827 if (frame_id_eq (old_frame_id,
1828 get_frame_id (get_current_frame ())))
1829 print_what = SRC_LINE;
1830 else
1831 print_what = SRC_AND_LOC;
1832
1833 print_stack_frame (get_selected_frame (NULL), 1, print_what);
1834 do_displays ();
1835 }
1836 }
1837
1838 /* trace_find_command takes a trace frame number n,
1839 sends "QTFrame:<n>" to the target,
1840 and accepts a reply that may contain several optional pieces
1841 of information: a frame number, a tracepoint number, and an
1842 indication of whether this is a trap frame or a stepping frame.
1843
1844 The minimal response is just "OK" (which indicates that the
1845 target does not give us a frame number or a tracepoint number).
1846 Instead of that, the target may send us a string containing
1847 any combination of:
1848 F<hexnum> (gives the selected frame number)
1849 T<hexnum> (gives the selected tracepoint number)
1850 */
1851
1852 /* tfind command */
1853 static void
1854 trace_find_command (char *args, int from_tty)
1855 { /* this should only be called with a numeric argument */
1856 int frameno = -1;
1857
1858 if (current_trace_status ()->running && !current_trace_status ()->from_file)
1859 error ("May not look at trace frames while trace is running.");
1860
1861 if (args == 0 || *args == 0)
1862 { /* TFIND with no args means find NEXT trace frame. */
1863 if (traceframe_number == -1)
1864 frameno = 0; /* "next" is first one */
1865 else
1866 frameno = traceframe_number + 1;
1867 }
1868 else if (0 == strcmp (args, "-"))
1869 {
1870 if (traceframe_number == -1)
1871 error (_("not debugging trace buffer"));
1872 else if (from_tty && traceframe_number == 0)
1873 error (_("already at start of trace buffer"));
1874
1875 frameno = traceframe_number - 1;
1876 }
1877 /* A hack to work around eval's need for fp to have been collected. */
1878 else if (0 == strcmp (args, "-1"))
1879 frameno = -1;
1880 else
1881 frameno = parse_and_eval_long (args);
1882
1883 if (frameno < -1)
1884 error (_("invalid input (%d is less than zero)"), frameno);
1885
1886 finish_tfind_command (tfind_number, frameno, 0, 0, from_tty);
1887 }
1888
1889 /* tfind end */
1890 static void
1891 trace_find_end_command (char *args, int from_tty)
1892 {
1893 trace_find_command ("-1", from_tty);
1894 }
1895
1896 /* tfind none */
1897 static void
1898 trace_find_none_command (char *args, int from_tty)
1899 {
1900 trace_find_command ("-1", from_tty);
1901 }
1902
1903 /* tfind start */
1904 static void
1905 trace_find_start_command (char *args, int from_tty)
1906 {
1907 trace_find_command ("0", from_tty);
1908 }
1909
1910 /* tfind pc command */
1911 static void
1912 trace_find_pc_command (char *args, int from_tty)
1913 {
1914 CORE_ADDR pc;
1915 char tmp[40];
1916
1917 if (current_trace_status ()->running && !current_trace_status ()->from_file)
1918 error ("May not look at trace frames while trace is running.");
1919
1920 if (args == 0 || *args == 0)
1921 pc = regcache_read_pc (get_current_regcache ());
1922 else
1923 pc = parse_and_eval_address (args);
1924
1925 finish_tfind_command (tfind_pc, 0, pc, 0, from_tty);
1926 }
1927
1928 /* tfind tracepoint command */
1929 static void
1930 trace_find_tracepoint_command (char *args, int from_tty)
1931 {
1932 int tdp;
1933 struct breakpoint *tp;
1934
1935 if (current_trace_status ()->running && !current_trace_status ()->from_file)
1936 error ("May not look at trace frames while trace is running.");
1937
1938 if (args == 0 || *args == 0)
1939 {
1940 if (tracepoint_number == -1)
1941 error (_("No current tracepoint -- please supply an argument."));
1942 else
1943 tdp = tracepoint_number; /* default is current TDP */
1944 }
1945 else
1946 tdp = parse_and_eval_long (args);
1947
1948 /* If we have the tracepoint on hand, use the number that the
1949 target knows about (which may be different if we disconnected
1950 and reconnected). */
1951 tp = get_tracepoint (tdp);
1952 if (tp)
1953 tdp = tp->number_on_target;
1954
1955 finish_tfind_command (tfind_tp, tdp, 0, 0, from_tty);
1956 }
1957
1958 /* TFIND LINE command:
1959
1960 This command will take a sourceline for argument, just like BREAK
1961 or TRACE (ie. anything that "decode_line_1" can handle).
1962
1963 With no argument, this command will find the next trace frame
1964 corresponding to a source line OTHER THAN THE CURRENT ONE. */
1965
1966 static void
1967 trace_find_line_command (char *args, int from_tty)
1968 {
1969 static CORE_ADDR start_pc, end_pc;
1970 struct symtabs_and_lines sals;
1971 struct symtab_and_line sal;
1972 struct cleanup *old_chain;
1973 char startpc_str[40], endpc_str[40];
1974
1975 if (current_trace_status ()->running && !current_trace_status ()->from_file)
1976 error ("May not look at trace frames while trace is running.");
1977
1978 if (args == 0 || *args == 0)
1979 {
1980 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
1981 sals.nelts = 1;
1982 sals.sals = (struct symtab_and_line *)
1983 xmalloc (sizeof (struct symtab_and_line));
1984 sals.sals[0] = sal;
1985 }
1986 else
1987 {
1988 sals = decode_line_spec (args, 1);
1989 sal = sals.sals[0];
1990 }
1991
1992 old_chain = make_cleanup (xfree, sals.sals);
1993 if (sal.symtab == 0)
1994 {
1995 printf_filtered ("TFIND: No line number information available");
1996 if (sal.pc != 0)
1997 {
1998 /* This is useful for "info line *0x7f34". If we can't
1999 tell the user about a source line, at least let them
2000 have the symbolic address. */
2001 printf_filtered (" for address ");
2002 wrap_here (" ");
2003 print_address (get_current_arch (), sal.pc, gdb_stdout);
2004 printf_filtered (";\n -- will attempt to find by PC. \n");
2005 }
2006 else
2007 {
2008 printf_filtered (".\n");
2009 return; /* No line, no PC; what can we do? */
2010 }
2011 }
2012 else if (sal.line > 0
2013 && find_line_pc_range (sal, &start_pc, &end_pc))
2014 {
2015 if (start_pc == end_pc)
2016 {
2017 printf_filtered ("Line %d of \"%s\"",
2018 sal.line, sal.symtab->filename);
2019 wrap_here (" ");
2020 printf_filtered (" is at address ");
2021 print_address (get_current_arch (), start_pc, gdb_stdout);
2022 wrap_here (" ");
2023 printf_filtered (" but contains no code.\n");
2024 sal = find_pc_line (start_pc, 0);
2025 if (sal.line > 0
2026 && find_line_pc_range (sal, &start_pc, &end_pc)
2027 && start_pc != end_pc)
2028 printf_filtered ("Attempting to find line %d instead.\n",
2029 sal.line);
2030 else
2031 error (_("Cannot find a good line."));
2032 }
2033 }
2034 else
2035 /* Is there any case in which we get here, and have an address
2036 which the user would want to see? If we have debugging
2037 symbols and no line numbers? */
2038 error (_("Line number %d is out of range for \"%s\"."),
2039 sal.line, sal.symtab->filename);
2040
2041 /* Find within range of stated line. */
2042 if (args && *args)
2043 finish_tfind_command (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2044 else
2045 finish_tfind_command (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2046 do_cleanups (old_chain);
2047 }
2048
2049 /* tfind range command */
2050 static void
2051 trace_find_range_command (char *args, int from_tty)
2052 {
2053 static CORE_ADDR start, stop;
2054 char start_str[40], stop_str[40];
2055 char *tmp;
2056
2057 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2058 error ("May not look at trace frames while trace is running.");
2059
2060 if (args == 0 || *args == 0)
2061 { /* XXX FIXME: what should default behavior be? */
2062 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2063 return;
2064 }
2065
2066 if (0 != (tmp = strchr (args, ',')))
2067 {
2068 *tmp++ = '\0'; /* terminate start address */
2069 while (isspace ((int) *tmp))
2070 tmp++;
2071 start = parse_and_eval_address (args);
2072 stop = parse_and_eval_address (tmp);
2073 }
2074 else
2075 { /* no explicit end address? */
2076 start = parse_and_eval_address (args);
2077 stop = start + 1; /* ??? */
2078 }
2079
2080 finish_tfind_command (tfind_range, 0, start, stop, from_tty);
2081 }
2082
2083 /* tfind outside command */
2084 static void
2085 trace_find_outside_command (char *args, int from_tty)
2086 {
2087 CORE_ADDR start, stop;
2088 char start_str[40], stop_str[40];
2089 char *tmp;
2090
2091 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2092 error ("May not look at trace frames while trace is running.");
2093
2094 if (args == 0 || *args == 0)
2095 { /* XXX FIXME: what should default behavior be? */
2096 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2097 return;
2098 }
2099
2100 if (0 != (tmp = strchr (args, ',')))
2101 {
2102 *tmp++ = '\0'; /* terminate start address */
2103 while (isspace ((int) *tmp))
2104 tmp++;
2105 start = parse_and_eval_address (args);
2106 stop = parse_and_eval_address (tmp);
2107 }
2108 else
2109 { /* no explicit end address? */
2110 start = parse_and_eval_address (args);
2111 stop = start + 1; /* ??? */
2112 }
2113
2114 finish_tfind_command (tfind_outside, 0, start, stop, from_tty);
2115 }
2116
2117 /* info scope command: list the locals for a scope. */
2118 static void
2119 scope_info (char *args, int from_tty)
2120 {
2121 struct symtabs_and_lines sals;
2122 struct symbol *sym;
2123 struct minimal_symbol *msym;
2124 struct block *block;
2125 char **canonical, *symname, *save_args = args;
2126 struct dict_iterator iter;
2127 int j, count = 0;
2128 struct gdbarch *gdbarch;
2129 int regno;
2130
2131 if (args == 0 || *args == 0)
2132 error (_("requires an argument (function, line or *addr) to define a scope"));
2133
2134 sals = decode_line_1 (&args, 1, NULL, 0, &canonical, NULL);
2135 if (sals.nelts == 0)
2136 return; /* presumably decode_line_1 has already warned */
2137
2138 /* Resolve line numbers to PC */
2139 resolve_sal_pc (&sals.sals[0]);
2140 block = block_for_pc (sals.sals[0].pc);
2141
2142 while (block != 0)
2143 {
2144 QUIT; /* allow user to bail out with ^C */
2145 ALL_BLOCK_SYMBOLS (block, iter, sym)
2146 {
2147 QUIT; /* allow user to bail out with ^C */
2148 if (count == 0)
2149 printf_filtered ("Scope for %s:\n", save_args);
2150 count++;
2151
2152 symname = SYMBOL_PRINT_NAME (sym);
2153 if (symname == NULL || *symname == '\0')
2154 continue; /* probably botched, certainly useless */
2155
2156 gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
2157
2158 printf_filtered ("Symbol %s is ", symname);
2159 switch (SYMBOL_CLASS (sym))
2160 {
2161 default:
2162 case LOC_UNDEF: /* messed up symbol? */
2163 printf_filtered ("a bogus symbol, class %d.\n",
2164 SYMBOL_CLASS (sym));
2165 count--; /* don't count this one */
2166 continue;
2167 case LOC_CONST:
2168 printf_filtered ("a constant with value %ld (0x%lx)",
2169 SYMBOL_VALUE (sym), SYMBOL_VALUE (sym));
2170 break;
2171 case LOC_CONST_BYTES:
2172 printf_filtered ("constant bytes: ");
2173 if (SYMBOL_TYPE (sym))
2174 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2175 fprintf_filtered (gdb_stdout, " %02x",
2176 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2177 break;
2178 case LOC_STATIC:
2179 printf_filtered ("in static storage at address ");
2180 printf_filtered ("%s", paddress (gdbarch,
2181 SYMBOL_VALUE_ADDRESS (sym)));
2182 break;
2183 case LOC_REGISTER:
2184 /* GDBARCH is the architecture associated with the objfile
2185 the symbol is defined in; the target architecture may be
2186 different, and may provide additional registers. However,
2187 we do not know the target architecture at this point.
2188 We assume the objfile architecture will contain all the
2189 standard registers that occur in debug info in that
2190 objfile. */
2191 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
2192
2193 if (SYMBOL_IS_ARGUMENT (sym))
2194 printf_filtered ("an argument in register $%s",
2195 gdbarch_register_name (gdbarch, regno));
2196 else
2197 printf_filtered ("a local variable in register $%s",
2198 gdbarch_register_name (gdbarch, regno));
2199 break;
2200 case LOC_ARG:
2201 printf_filtered ("an argument at stack/frame offset %ld",
2202 SYMBOL_VALUE (sym));
2203 break;
2204 case LOC_LOCAL:
2205 printf_filtered ("a local variable at frame offset %ld",
2206 SYMBOL_VALUE (sym));
2207 break;
2208 case LOC_REF_ARG:
2209 printf_filtered ("a reference argument at offset %ld",
2210 SYMBOL_VALUE (sym));
2211 break;
2212 case LOC_REGPARM_ADDR:
2213 /* Note comment at LOC_REGISTER. */
2214 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
2215 printf_filtered ("the address of an argument, in register $%s",
2216 gdbarch_register_name (gdbarch, regno));
2217 break;
2218 case LOC_TYPEDEF:
2219 printf_filtered ("a typedef.\n");
2220 continue;
2221 case LOC_LABEL:
2222 printf_filtered ("a label at address ");
2223 printf_filtered ("%s", paddress (gdbarch,
2224 SYMBOL_VALUE_ADDRESS (sym)));
2225 break;
2226 case LOC_BLOCK:
2227 printf_filtered ("a function at address ");
2228 printf_filtered ("%s",
2229 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2230 break;
2231 case LOC_UNRESOLVED:
2232 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2233 NULL, NULL);
2234 if (msym == NULL)
2235 printf_filtered ("Unresolved Static");
2236 else
2237 {
2238 printf_filtered ("static storage at address ");
2239 printf_filtered ("%s",
2240 paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msym)));
2241 }
2242 break;
2243 case LOC_OPTIMIZED_OUT:
2244 printf_filtered ("optimized out.\n");
2245 continue;
2246 case LOC_COMPUTED:
2247 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym, gdb_stdout);
2248 break;
2249 }
2250 if (SYMBOL_TYPE (sym))
2251 printf_filtered (", length %d.\n",
2252 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2253 }
2254 if (BLOCK_FUNCTION (block))
2255 break;
2256 else
2257 block = BLOCK_SUPERBLOCK (block);
2258 }
2259 if (count <= 0)
2260 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2261 save_args);
2262 }
2263
2264 /* worker function (cleanup) */
2265 static void
2266 replace_comma (void *data)
2267 {
2268 char *comma = data;
2269 *comma = ',';
2270 }
2271
2272 /* tdump command */
2273 static void
2274 trace_dump_command (char *args, int from_tty)
2275 {
2276 struct regcache *regcache;
2277 struct gdbarch *gdbarch;
2278 struct breakpoint *t;
2279 struct action_line *action;
2280 char *action_exp, *next_comma;
2281 struct cleanup *old_cleanups;
2282 int stepping_actions = 0;
2283 int stepping_frame = 0;
2284 struct bp_location *loc;
2285
2286 if (tracepoint_number == -1)
2287 {
2288 warning (_("No current trace frame."));
2289 return;
2290 }
2291
2292 t = get_tracepoint (tracepoint_number);
2293
2294 if (t == NULL)
2295 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2296 tracepoint_number);
2297
2298 old_cleanups = make_cleanup (null_cleanup, NULL);
2299
2300 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2301 tracepoint_number, traceframe_number);
2302
2303 /* The current frame is a trap frame if the frame PC is equal
2304 to the tracepoint PC. If not, then the current frame was
2305 collected during single-stepping. */
2306
2307 regcache = get_current_regcache ();
2308 gdbarch = get_regcache_arch (regcache);
2309
2310 /* If the traceframe's address matches any of the tracepoint's
2311 locations, assume it is a direct hit rather than a while-stepping
2312 frame. (FIXME this is not reliable, should record each frame's
2313 type.) */
2314 stepping_frame = 1;
2315 for (loc = t->loc; loc; loc = loc->next)
2316 if (loc->address == regcache_read_pc (regcache))
2317 stepping_frame = 0;
2318
2319 for (action = t->actions; action; action = action->next)
2320 {
2321 struct cmd_list_element *cmd;
2322
2323 QUIT; /* allow user to bail out with ^C */
2324 action_exp = action->action;
2325 while (isspace ((int) *action_exp))
2326 action_exp++;
2327
2328 /* The collection actions to be done while stepping are
2329 bracketed by the commands "while-stepping" and "end". */
2330
2331 if (*action_exp == '#') /* comment line */
2332 continue;
2333
2334 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2335 if (cmd == 0)
2336 error (_("Bad action list item: %s"), action_exp);
2337
2338 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2339 stepping_actions = 1;
2340 else if (cmd_cfunc_eq (cmd, end_actions_pseudocommand))
2341 stepping_actions = 0;
2342 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2343 {
2344 /* Display the collected data.
2345 For the trap frame, display only what was collected at
2346 the trap. Likewise for stepping frames, display only
2347 what was collected while stepping. This means that the
2348 two boolean variables, STEPPING_FRAME and
2349 STEPPING_ACTIONS should be equal. */
2350 if (stepping_frame == stepping_actions)
2351 {
2352 do
2353 { /* repeat over a comma-separated list */
2354 QUIT; /* allow user to bail out with ^C */
2355 if (*action_exp == ',')
2356 action_exp++;
2357 while (isspace ((int) *action_exp))
2358 action_exp++;
2359
2360 next_comma = strchr (action_exp, ',');
2361
2362 if (0 == strncasecmp (action_exp, "$reg", 4))
2363 registers_info (NULL, from_tty);
2364 else if (0 == strncasecmp (action_exp, "$loc", 4))
2365 locals_info (NULL, from_tty);
2366 else if (0 == strncasecmp (action_exp, "$arg", 4))
2367 args_info (NULL, from_tty);
2368 else
2369 { /* variable */
2370 if (next_comma)
2371 {
2372 make_cleanup (replace_comma, next_comma);
2373 *next_comma = '\0';
2374 }
2375 printf_filtered ("%s = ", action_exp);
2376 output_command (action_exp, from_tty);
2377 printf_filtered ("\n");
2378 }
2379 if (next_comma)
2380 *next_comma = ',';
2381 action_exp = next_comma;
2382 }
2383 while (action_exp && *action_exp == ',');
2384 }
2385 }
2386 }
2387 discard_cleanups (old_cleanups);
2388 }
2389
2390 extern int trace_regblock_size;
2391
2392 static void
2393 trace_save_command (char *args, int from_tty)
2394 {
2395 char **argv;
2396 char *filename = NULL, *pathname;
2397 int target_does_save = 0;
2398 struct cleanup *cleanup;
2399 struct trace_status *ts = current_trace_status ();
2400 int err, status;
2401 FILE *fp;
2402 struct uploaded_tp *uploaded_tps = NULL, *utp;
2403 struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
2404 int a;
2405 LONGEST gotten = 0;
2406 ULONGEST offset = 0;
2407 #define MAX_TRACE_UPLOAD 2000
2408 gdb_byte buf[MAX_TRACE_UPLOAD];
2409 int written;
2410
2411 if (args == NULL)
2412 error_no_arg (_("file in which to save trace data"));
2413
2414 argv = gdb_buildargv (args);
2415 make_cleanup_freeargv (argv);
2416
2417 for (; *argv; ++argv)
2418 {
2419 if (strcmp (*argv, "-r") == 0)
2420 target_does_save = 1;
2421 else if (**argv == '-')
2422 error (_("unknown option `%s'"), *argv);
2423 else
2424 filename = *argv;
2425 }
2426
2427 if (!filename)
2428 error_no_arg (_("file in which to save trace data"));
2429
2430 /* If the target is to save the data to a file on its own, then just
2431 send the command and be done with it. */
2432 if (target_does_save)
2433 {
2434 err = target_save_trace_data (filename);
2435 if (err < 0)
2436 error (_("Target failed to save trace data to '%s'."),
2437 filename);
2438 return;
2439 }
2440
2441 /* Get the trace status first before opening the file, so if the
2442 target is losing, we can get out without touching files. */
2443 status = target_get_trace_status (ts);
2444
2445 pathname = tilde_expand (args);
2446 cleanup = make_cleanup (xfree, pathname);
2447
2448 fp = fopen (pathname, "w");
2449 if (!fp)
2450 error (_("Unable to open file '%s' for saving trace data (%s)"),
2451 args, safe_strerror (errno));
2452 make_cleanup_fclose (fp);
2453
2454 /* Write a file header, with a high-bit-set char to indicate a
2455 binary file, plus a hint as what this file is, and a version
2456 number in case of future needs. */
2457 written = fwrite ("\x7fTRACE0\n", 8, 1, fp);
2458 if (written < 8)
2459 perror_with_name (pathname);
2460
2461 /* Write descriptive info. */
2462
2463 /* Write out the size of a register block. */
2464 fprintf (fp, "R %x\n", trace_regblock_size);
2465
2466 /* Write out status of the tracing run (aka "tstatus" info). */
2467 fprintf (fp, "status %c;%s:%x",
2468 (ts->running ? '1' : '0'),
2469 stop_reason_names[ts->stop_reason], ts->stopping_tracepoint);
2470 if (ts->traceframe_count >= 0)
2471 fprintf (fp, ";tframes:%x", ts->traceframe_count);
2472 if (ts->traceframes_created >= 0)
2473 fprintf (fp, ";tcreated:%x", ts->traceframes_created);
2474 if (ts->buffer_free >= 0)
2475 fprintf (fp, ";tfree:%x", ts->buffer_free);
2476 if (ts->buffer_size >= 0)
2477 fprintf (fp, ";tsize:%x", ts->buffer_size);
2478 fprintf (fp, "\n");
2479
2480 /* Note that we want to upload tracepoints and save those, rather
2481 than simply writing out the local ones, because the user may have
2482 changed tracepoints in GDB in preparation for a future tracing
2483 run, or maybe just mass-deleted all types of breakpoints as part
2484 of cleaning up. So as not to contaminate the session, leave the
2485 data in its uploaded form, don't make into real tracepoints. */
2486
2487 /* Get trace state variables first, they may be checked when parsing
2488 uploaded commands. */
2489
2490 target_upload_trace_state_variables (&uploaded_tsvs);
2491
2492 for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
2493 {
2494 char *buf = "";
2495
2496 if (utsv->name)
2497 {
2498 buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
2499 bin2hex ((gdb_byte *) (utsv->name), buf, 0);
2500 }
2501
2502 fprintf (fp, "tsv %x:%s:%x:%s\n",
2503 utsv->number, phex_nz (utsv->initial_value, 8),
2504 utsv->builtin, buf);
2505
2506 if (utsv->name)
2507 xfree (buf);
2508 }
2509
2510 free_uploaded_tsvs (&uploaded_tsvs);
2511
2512 target_upload_tracepoints (&uploaded_tps);
2513
2514 for (utp = uploaded_tps; utp; utp = utp->next)
2515 {
2516 fprintf (fp, "tp T%x:%s:%c:%x:%x",
2517 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
2518 (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
2519 if (utp->type == bp_fast_tracepoint)
2520 fprintf (fp, ":F%x", utp->orig_size);
2521 if (utp->cond)
2522 fprintf (fp, ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
2523 utp->cond);
2524 fprintf (fp, "\n");
2525 for (a = 0; a < utp->numactions; ++a)
2526 fprintf (fp, "tp A%x:%s:%s\n",
2527 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
2528 utp->actions[a]);
2529 for (a = 0; a < utp->num_step_actions; ++a)
2530 fprintf (fp, "tp S%x:%s:%s\n",
2531 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
2532 utp->step_actions[a]);
2533 }
2534
2535 free_uploaded_tps (&uploaded_tps);
2536
2537 /* Mark the end of the definition section. */
2538 fprintf (fp, "\n");
2539
2540 /* Get and write the trace data proper. We ask for big blocks, in
2541 the hopes of efficiency, but will take less if the target has
2542 packet size limitations or some such. */
2543 while (1)
2544 {
2545 gotten = target_get_raw_trace_data (buf, offset, MAX_TRACE_UPLOAD);
2546 if (gotten < 0)
2547 error (_("Failure to get requested trace buffer data"));
2548 /* No more data is forthcoming, we're done. */
2549 if (gotten == 0)
2550 break;
2551 written = fwrite (buf, gotten, 1, fp);
2552 if (written < gotten)
2553 perror_with_name (pathname);
2554 offset += gotten;
2555 }
2556
2557 /* Mark the end of trace data. */
2558 written = fwrite (&gotten, 4, 1, fp);
2559 if (written < 4)
2560 perror_with_name (pathname);
2561
2562 do_cleanups (cleanup);
2563 if (from_tty)
2564 printf_filtered (_("Trace data saved to file '%s'.\n"), args);
2565 }
2566
2567 /* Tell the target what to do with an ongoing tracing run if GDB
2568 disconnects for some reason. */
2569
2570 void
2571 send_disconnected_tracing_value (int value)
2572 {
2573 target_set_disconnected_tracing (value);
2574 }
2575
2576 static void
2577 set_disconnected_tracing (char *args, int from_tty,
2578 struct cmd_list_element *c)
2579 {
2580 send_disconnected_tracing_value (disconnected_tracing);
2581 }
2582
2583 static void
2584 set_circular_trace_buffer (char *args, int from_tty,
2585 struct cmd_list_element *c)
2586 {
2587 target_set_circular_trace_buffer (circular_trace_buffer);
2588 }
2589
2590 /* Convert the memory pointed to by mem into hex, placing result in buf.
2591 * Return a pointer to the last char put in buf (null)
2592 * "stolen" from sparc-stub.c
2593 */
2594
2595 static const char hexchars[] = "0123456789abcdef";
2596
2597 static char *
2598 mem2hex (gdb_byte *mem, char *buf, int count)
2599 {
2600 gdb_byte ch;
2601
2602 while (count-- > 0)
2603 {
2604 ch = *mem++;
2605
2606 *buf++ = hexchars[ch >> 4];
2607 *buf++ = hexchars[ch & 0xf];
2608 }
2609
2610 *buf = 0;
2611
2612 return buf;
2613 }
2614
2615 int
2616 get_traceframe_number (void)
2617 {
2618 return traceframe_number;
2619 }
2620
2621 /* Make the traceframe NUM be the current trace frame. Does nothing
2622 if NUM is already current. */
2623
2624 void
2625 set_traceframe_number (int num)
2626 {
2627 int newnum;
2628
2629 if (traceframe_number == num)
2630 {
2631 /* Nothing to do. */
2632 return;
2633 }
2634
2635 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
2636
2637 if (newnum != num)
2638 warning (_("could not change traceframe"));
2639
2640 traceframe_number = newnum;
2641
2642 /* Changing the traceframe changes our view of registers and of the
2643 frame chain. */
2644 registers_changed ();
2645 }
2646
2647 /* A cleanup used when switching away and back from tfind mode. */
2648
2649 struct current_traceframe_cleanup
2650 {
2651 /* The traceframe we were inspecting. */
2652 int traceframe_number;
2653 };
2654
2655 static void
2656 do_restore_current_traceframe_cleanup (void *arg)
2657 {
2658 struct current_traceframe_cleanup *old = arg;
2659
2660 set_traceframe_number (old->traceframe_number);
2661 }
2662
2663 static void
2664 restore_current_traceframe_cleanup_dtor (void *arg)
2665 {
2666 struct current_traceframe_cleanup *old = arg;
2667
2668 xfree (old);
2669 }
2670
2671 struct cleanup *
2672 make_cleanup_restore_current_traceframe (void)
2673 {
2674 struct current_traceframe_cleanup *old;
2675
2676 old = xmalloc (sizeof (struct current_traceframe_cleanup));
2677 old->traceframe_number = traceframe_number;
2678
2679 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
2680 restore_current_traceframe_cleanup_dtor);
2681 }
2682
2683 /* Given a number and address, return an uploaded tracepoint with that
2684 number, creating if necessary. */
2685
2686 struct uploaded_tp *
2687 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
2688 {
2689 struct uploaded_tp *utp;
2690
2691 for (utp = *utpp; utp; utp = utp->next)
2692 if (utp->number == num && utp->addr == addr)
2693 return utp;
2694 utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
2695 memset (utp, 0, sizeof (struct uploaded_tp));
2696 utp->number = num;
2697 utp->addr = addr;
2698 utp->next = *utpp;
2699 *utpp = utp;
2700 return utp;
2701 }
2702
2703 static void
2704 free_uploaded_tps (struct uploaded_tp **utpp)
2705 {
2706 struct uploaded_tp *next_one;
2707
2708 while (*utpp)
2709 {
2710 next_one = (*utpp)->next;
2711 xfree (*utpp);
2712 *utpp = next_one;
2713 }
2714 }
2715
2716 /* Given a number and address, return an uploaded tracepoint with that
2717 number, creating if necessary. */
2718
2719 struct uploaded_tsv *
2720 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
2721 {
2722 struct uploaded_tsv *utsv;
2723
2724 for (utsv = *utsvp; utsv; utsv = utsv->next)
2725 if (utsv->number == num)
2726 return utsv;
2727 utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
2728 memset (utsv, 0, sizeof (struct uploaded_tsv));
2729 utsv->number = num;
2730 utsv->next = *utsvp;
2731 *utsvp = utsv;
2732 return utsv;
2733 }
2734
2735 static void
2736 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
2737 {
2738 struct uploaded_tsv *next_one;
2739
2740 while (*utsvp)
2741 {
2742 next_one = (*utsvp)->next;
2743 xfree (*utsvp);
2744 *utsvp = next_one;
2745 }
2746 }
2747
2748 /* Look for an existing tracepoint that seems similar enough to the
2749 uploaded one. Enablement isn't compared, because the user can
2750 toggle that freely, and may have done so in anticipation of the
2751 next trace run. */
2752
2753 struct breakpoint *
2754 find_matching_tracepoint (struct uploaded_tp *utp)
2755 {
2756 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
2757 int ix;
2758 struct breakpoint *t;
2759 struct bp_location *loc;
2760
2761 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
2762 {
2763 if (t->type == utp->type
2764 && t->step_count == utp->step
2765 && t->pass_count == utp->pass
2766 /* FIXME also test conditionals and actions */
2767 )
2768 {
2769 /* Scan the locations for an address match. */
2770 for (loc = t->loc; loc; loc = loc->next)
2771 {
2772 if (loc->address == utp->addr)
2773 return t;
2774 }
2775 }
2776 }
2777 return NULL;
2778 }
2779
2780 /* Given a list of tracepoints uploaded from a target, attempt to
2781 match them up with existing tracepoints, and create new ones if not
2782 found. */
2783
2784 void
2785 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
2786 {
2787 struct uploaded_tp *utp;
2788 struct breakpoint *t;
2789
2790 /* Look for GDB tracepoints that match up with our uploaded versions. */
2791 for (utp = *uploaded_tps; utp; utp = utp->next)
2792 {
2793 t = find_matching_tracepoint (utp);
2794 if (t)
2795 printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
2796 t->number, utp->number, paddress (get_current_arch (), utp->addr));
2797 else
2798 {
2799 t = create_tracepoint_from_upload (utp);
2800 if (t)
2801 printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
2802 t->number, utp->number, paddress (get_current_arch (), utp->addr));
2803 else
2804 printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
2805 utp->number, paddress (get_current_arch (), utp->addr));
2806 }
2807 /* Whether found or created, record the number used by the
2808 target, to help with mapping target tracepoints back to their
2809 counterparts here. */
2810 if (t)
2811 t->number_on_target = utp->number;
2812 }
2813
2814 free_uploaded_tps (uploaded_tps);
2815 }
2816
2817 /* Trace state variables don't have much to identify them beyond their
2818 name, so just use that to detect matches. */
2819
2820 struct trace_state_variable *
2821 find_matching_tsv (struct uploaded_tsv *utsv)
2822 {
2823 if (!utsv->name)
2824 return NULL;
2825
2826 return find_trace_state_variable (utsv->name);
2827 }
2828
2829 struct trace_state_variable *
2830 create_tsv_from_upload (struct uploaded_tsv *utsv)
2831 {
2832 const char *namebase;
2833 char buf[20];
2834 int try_num = 0;
2835 struct trace_state_variable *tsv;
2836
2837 if (utsv->name)
2838 {
2839 namebase = utsv->name;
2840 sprintf (buf, "%s", namebase);
2841 }
2842 else
2843 {
2844 namebase = "__tsv";
2845 sprintf (buf, "%s_%d", namebase, try_num++);
2846 }
2847
2848 /* Fish for a name that is not in use. */
2849 /* (should check against all internal vars?) */
2850 while (find_trace_state_variable (buf))
2851 sprintf (buf, "%s_%d", namebase, try_num++);
2852
2853 /* We have an available name, create the variable. */
2854 tsv = create_trace_state_variable (xstrdup (buf));
2855 tsv->initial_value = utsv->initial_value;
2856 tsv->builtin = utsv->builtin;
2857
2858 return tsv;
2859 }
2860
2861 /* Given a list of uploaded trace state variables, try to match them
2862 up with existing variables, or create additional ones. */
2863
2864 void
2865 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
2866 {
2867 int ix;
2868 struct uploaded_tsv *utsv;
2869 struct trace_state_variable *tsv;
2870 int highest;
2871
2872 /* Most likely some numbers will have to be reassigned as part of
2873 the merge, so clear them all in anticipation. */
2874 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
2875 tsv->number = 0;
2876
2877 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
2878 {
2879 tsv = find_matching_tsv (utsv);
2880 if (tsv)
2881 printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
2882 tsv->name, utsv->number);
2883 else
2884 {
2885 tsv = create_tsv_from_upload (utsv);
2886 printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
2887 tsv->name, utsv->number);
2888 }
2889 /* Give precedence to numberings that come from the target. */
2890 if (tsv)
2891 tsv->number = utsv->number;
2892 }
2893
2894 /* Renumber everything that didn't get a target-assigned number. */
2895 highest = 0;
2896 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
2897 if (tsv->number > highest)
2898 highest = tsv->number;
2899
2900 ++highest;
2901 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
2902 if (tsv->number == 0)
2903 tsv->number = highest++;
2904
2905 free_uploaded_tsvs (uploaded_tsvs);
2906 }
2907
2908 /* target tfile command */
2909
2910 struct target_ops tfile_ops;
2911
2912 /* Fill in tfile_ops with its defined operations and properties. */
2913
2914 #define TRACE_HEADER_SIZE 8
2915
2916 char *trace_filename;
2917 int trace_fd = -1;
2918 off_t trace_frames_offset;
2919 off_t cur_offset;
2920 int cur_data_size;
2921 int trace_regblock_size;
2922
2923 static void tfile_interp_line (char *line,
2924 struct uploaded_tp **utpp,
2925 struct uploaded_tsv **utsvp);
2926
2927 static void
2928 tfile_open (char *filename, int from_tty)
2929 {
2930 char *temp;
2931 struct cleanup *old_chain;
2932 int flags;
2933 int scratch_chan;
2934 char header[TRACE_HEADER_SIZE];
2935 char linebuf[1000]; /* should be max remote packet size or so */
2936 char byte;
2937 int bytes, i, gotten;
2938 struct trace_status *ts;
2939 struct uploaded_tp *uploaded_tps = NULL;
2940 struct uploaded_tsv *uploaded_tsvs = NULL;
2941
2942 target_preopen (from_tty);
2943 if (!filename)
2944 error (_("No trace file specified."));
2945
2946 filename = tilde_expand (filename);
2947 if (!IS_ABSOLUTE_PATH(filename))
2948 {
2949 temp = concat (current_directory, "/", filename, (char *)NULL);
2950 xfree (filename);
2951 filename = temp;
2952 }
2953
2954 old_chain = make_cleanup (xfree, filename);
2955
2956 flags = O_BINARY | O_LARGEFILE;
2957 flags |= O_RDONLY;
2958 scratch_chan = open (filename, flags, 0);
2959 if (scratch_chan < 0)
2960 perror_with_name (filename);
2961
2962 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
2963
2964 discard_cleanups (old_chain); /* Don't free filename any more */
2965 unpush_target (&tfile_ops);
2966
2967 push_target (&tfile_ops);
2968
2969 trace_filename = xstrdup (filename);
2970 trace_fd = scratch_chan;
2971
2972 bytes = 0;
2973 /* Read the file header and test for validity. */
2974 gotten = read (trace_fd, &header, TRACE_HEADER_SIZE);
2975 if (gotten < 0)
2976 perror_with_name (trace_filename);
2977 else if (gotten < TRACE_HEADER_SIZE)
2978 error (_("Premature end of file while reading trace file"));
2979
2980 bytes += TRACE_HEADER_SIZE;
2981 if (!(header[0] == 0x7f
2982 && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
2983 error (_("File is not a valid trace file."));
2984
2985 trace_regblock_size = 0;
2986 ts = current_trace_status ();
2987 /* We know we're working with a file. */
2988 ts->from_file = 1;
2989 /* Set defaults in case there is no status line. */
2990 ts->running_known = 0;
2991 ts->stop_reason = trace_stop_reason_unknown;
2992 ts->traceframe_count = -1;
2993 ts->buffer_free = 0;
2994
2995 /* Read through a section of newline-terminated lines that
2996 define things like tracepoints. */
2997 i = 0;
2998 while (1)
2999 {
3000 gotten = read (trace_fd, &byte, 1);
3001 if (gotten < 0)
3002 perror_with_name (trace_filename);
3003 else if (gotten < 1)
3004 error (_("Premature end of file while reading trace file"));
3005
3006 ++bytes;
3007 if (byte == '\n')
3008 {
3009 /* Empty line marks end of the definition section. */
3010 if (i == 0)
3011 break;
3012 linebuf[i] = '\0';
3013 i = 0;
3014 tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
3015 }
3016 else
3017 linebuf[i++] = byte;
3018 if (i >= 1000)
3019 error (_("Excessively long lines in trace file"));
3020 }
3021
3022 /* Add the file's tracepoints and variables into the current mix. */
3023
3024 /* Get trace state variables first, they may be checked when parsing
3025 uploaded commands. */
3026 merge_uploaded_trace_state_variables (&uploaded_tsvs);
3027
3028 merge_uploaded_tracepoints (&uploaded_tps);
3029
3030 /* Record the starting offset of the binary trace data. */
3031 trace_frames_offset = bytes;
3032
3033 /* If we don't have a blocksize, we can't interpret the
3034 traceframes. */
3035 if (trace_regblock_size == 0)
3036 error (_("No register block size recorded in trace file"));
3037 if (ts->traceframe_count <= 0)
3038 {
3039 warning ("No traceframes present in this file.");
3040 return;
3041 }
3042
3043 #define TFILE_PID (1)
3044 inferior_appeared (current_inferior (), TFILE_PID);
3045 inferior_ptid = pid_to_ptid (TFILE_PID);
3046 add_thread_silent (inferior_ptid);
3047
3048 post_create_inferior (&tfile_ops, from_tty);
3049
3050 #if 0
3051 /* FIXME this will get defined in MI patch submission */
3052 tfind_1 (tfind_number, 0, 0, 0, 0);
3053 #endif
3054 }
3055
3056 /* Interpret the given line from the definitions part of the trace
3057 file. */
3058
3059 static void
3060 tfile_interp_line (char *line,
3061 struct uploaded_tp **utpp, struct uploaded_tsv **utsvp)
3062 {
3063 char *p = line;
3064
3065 if (strncmp (p, "R ", strlen ("R ")) == 0)
3066 {
3067 p += strlen ("R ");
3068 trace_regblock_size = strtol (p, &p, 16);
3069 }
3070 else if (strncmp (p, "status ", strlen ("status ")) == 0)
3071 {
3072 p += strlen ("status ");
3073 parse_trace_status (p, current_trace_status ());
3074 }
3075 else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
3076 {
3077 p += strlen ("tp ");
3078 parse_tracepoint_definition (p, utpp);
3079 }
3080 else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
3081 {
3082 p += strlen ("tsv ");
3083 parse_tsv_definition (p, utsvp);
3084 }
3085 else
3086 warning ("Ignoring trace file definition \"%s\"", line);
3087 }
3088
3089 /* Parse the part of trace status syntax that is shared between
3090 the remote protocol and the trace file reader. */
3091
3092 extern char *unpack_varlen_hex (char *buff, ULONGEST *result);
3093
3094 void
3095 parse_trace_status (char *line, struct trace_status *ts)
3096 {
3097 char *p = line, *p1, *p_temp;
3098 ULONGEST val;
3099
3100 ts->running_known = 1;
3101 ts->running = (*p++ == '1');
3102 ts->stop_reason = trace_stop_reason_unknown;
3103 ts->traceframe_count = -1;
3104 ts->traceframes_created = -1;
3105 ts->buffer_free = -1;
3106 ts->buffer_size = -1;
3107
3108 while (*p++)
3109 {
3110 p1 = strchr (p, ':');
3111 if (p1 == NULL)
3112 error (_("Malformed trace status, at %s\n\
3113 Status line: '%s'\n"), p, line);
3114 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3115 {
3116 p = unpack_varlen_hex (++p1, &val);
3117 ts->stop_reason = trace_buffer_full;
3118 }
3119 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3120 {
3121 p = unpack_varlen_hex (++p1, &val);
3122 ts->stop_reason = trace_never_run;
3123 }
3124 else if (strncmp (p, stop_reason_names[tracepoint_passcount], p1 - p) == 0)
3125 {
3126 p = unpack_varlen_hex (++p1, &val);
3127 ts->stop_reason = tracepoint_passcount;
3128 ts->stopping_tracepoint = val;
3129 }
3130 else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
3131 {
3132 p = unpack_varlen_hex (++p1, &val);
3133 ts->stop_reason = tstop_command;
3134 }
3135 else if (strncmp (p, "tframes", p1 - p) == 0)
3136 {
3137 p = unpack_varlen_hex (++p1, &val);
3138 ts->traceframe_count = val;
3139 }
3140 else if (strncmp (p, "tcreated", p1 - p) == 0)
3141 {
3142 p = unpack_varlen_hex (++p1, &val);
3143 ts->traceframes_created = val;
3144 }
3145 else if (strncmp (p, "tfree", p1 - p) == 0)
3146 {
3147 p = unpack_varlen_hex (++p1, &val);
3148 ts->buffer_free = val;
3149 }
3150 else if (strncmp (p, "tsize", p1 - p) == 0)
3151 {
3152 p = unpack_varlen_hex (++p1, &val);
3153 ts->buffer_size = val;
3154 }
3155 else
3156 {
3157 /* Silently skip unknown optional info. */
3158 p_temp = strchr (p1 + 1, ';');
3159 if (p_temp)
3160 p = p_temp;
3161 else
3162 /* Must be at the end. */
3163 break;
3164 }
3165 }
3166 }
3167
3168 /* Given a line of text defining a tracepoint or tracepoint action, parse
3169 it into an "uploaded tracepoint". */
3170
3171 void
3172 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
3173 {
3174 char *p;
3175 char piece;
3176 ULONGEST num, addr, step, pass, orig_size, xlen;
3177 int enabled, i;
3178 enum bptype type;
3179 char *cond;
3180 struct uploaded_tp *utp = NULL;
3181
3182 p = line;
3183 /* Both tracepoint and action definitions start with the same number
3184 and address sequence. */
3185 piece = *p++;
3186 p = unpack_varlen_hex (p, &num);
3187 p++; /* skip a colon */
3188 p = unpack_varlen_hex (p, &addr);
3189 p++; /* skip a colon */
3190 if (piece == 'T')
3191 {
3192 enabled = (*p++ == 'E');
3193 p++; /* skip a colon */
3194 p = unpack_varlen_hex (p, &step);
3195 p++; /* skip a colon */
3196 p = unpack_varlen_hex (p, &pass);
3197 type = bp_tracepoint;
3198 cond = NULL;
3199 /* Thumb through optional fields. */
3200 while (*p == ':')
3201 {
3202 p++; /* skip a colon */
3203 if (*p == 'F')
3204 {
3205 type = bp_fast_tracepoint;
3206 p++;
3207 p = unpack_varlen_hex (p, &orig_size);
3208 }
3209 else if (*p == 'X')
3210 {
3211 p++;
3212 p = unpack_varlen_hex (p, &xlen);
3213 p++; /* skip a comma */
3214 cond = (char *) xmalloc (2 * xlen + 1);
3215 strncpy (cond, p, 2 * xlen);
3216 cond[2 * xlen] = '\0';
3217 p += 2 * xlen;
3218 }
3219 else
3220 warning ("Unrecognized char '%c' in tracepoint definition, skipping rest", *p);
3221 }
3222 utp = get_uploaded_tp (num, addr, utpp);
3223 utp->type = type;
3224 utp->enabled = enabled;
3225 utp->step = step;
3226 utp->pass = pass;
3227 utp->cond = cond;
3228 }
3229 else if (piece == 'A')
3230 {
3231 utp = get_uploaded_tp (num, addr, utpp);
3232 utp->actions[utp->numactions++] = xstrdup (p);
3233 }
3234 else if (piece == 'S')
3235 {
3236 utp = get_uploaded_tp (num, addr, utpp);
3237 utp->step_actions[utp->num_step_actions++] = xstrdup (p);
3238 }
3239 else
3240 {
3241 error ("Invalid tracepoint piece");
3242 }
3243 }
3244
3245 /* Convert a textual description of a trace state variable into an
3246 uploaded object. */
3247
3248 void
3249 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
3250 {
3251 char *p, *buf;
3252 ULONGEST num, initval, builtin;
3253 int end;
3254 struct uploaded_tsv *utsv = NULL;
3255
3256 buf = alloca (strlen (line));
3257
3258 p = line;
3259 p = unpack_varlen_hex (p, &num);
3260 p++; /* skip a colon */
3261 p = unpack_varlen_hex (p, &initval);
3262 p++; /* skip a colon */
3263 p = unpack_varlen_hex (p, &builtin);
3264 p++; /* skip a colon */
3265 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3266 buf[end] = '\0';
3267
3268 utsv = get_uploaded_tsv (num, utsvp);
3269 utsv->initial_value = initval;
3270 utsv->builtin = builtin;
3271 utsv->name = xstrdup (buf);
3272 }
3273
3274 /* Close the trace file and generally clean up. */
3275
3276 static void
3277 tfile_close (int quitting)
3278 {
3279 int pid;
3280
3281 if (trace_fd < 0)
3282 return;
3283
3284 pid = ptid_get_pid (inferior_ptid);
3285 inferior_ptid = null_ptid; /* Avoid confusion from thread stuff */
3286 exit_inferior_silent (pid);
3287
3288 close (trace_fd);
3289 trace_fd = -1;
3290 if (trace_filename)
3291 xfree (trace_filename);
3292 }
3293
3294 static void
3295 tfile_files_info (struct target_ops *t)
3296 {
3297 /* (it would be useful to mention the name of the file) */
3298 printf_filtered ("Looking at a trace file.\n");
3299 }
3300
3301 /* The trace status for a file is that tracing can never be run. */
3302
3303 static int
3304 tfile_get_trace_status (struct trace_status *ts)
3305 {
3306 /* Other bits of trace status were collected as part of opening the
3307 trace files, so nothing to do here. */
3308
3309 return -1;
3310 }
3311
3312 /* Given the position of a traceframe in the file, figure out what
3313 address the frame was collected at. This would normally be the
3314 value of a collected PC register, but if not available, we
3315 improvise. */
3316
3317 static ULONGEST
3318 tfile_get_traceframe_address (off_t tframe_offset)
3319 {
3320 ULONGEST addr = 0;
3321 short tpnum;
3322 struct breakpoint *tp;
3323 off_t saved_offset = cur_offset;
3324 int gotten;
3325
3326 /* FIXME dig pc out of collected registers */
3327
3328 /* Fall back to using tracepoint address. */
3329 lseek (trace_fd, tframe_offset, SEEK_SET);
3330 gotten = read (trace_fd, &tpnum, 2);
3331 if (gotten < 0)
3332 perror_with_name (trace_filename);
3333 else if (gotten < 2)
3334 error (_("Premature end of file while reading trace file"));
3335
3336 tp = get_tracepoint_by_number_on_target (tpnum);
3337 /* FIXME this is a poor heuristic if multiple locations */
3338 if (tp && tp->loc)
3339 addr = tp->loc->address;
3340
3341 /* Restore our seek position. */
3342 cur_offset = saved_offset;
3343 lseek (trace_fd, cur_offset, SEEK_SET);
3344 return addr;
3345 }
3346
3347 /* Given a type of search and some parameters, scan the collection of
3348 traceframes in the file looking for a match. When found, return
3349 both the traceframe and tracepoint number, otherwise -1 for
3350 each. */
3351
3352 static int
3353 tfile_trace_find (enum trace_find_type type, int num,
3354 ULONGEST addr1, ULONGEST addr2, int *tpp)
3355 {
3356 short tpnum;
3357 int tfnum = 0, found = 0, gotten;
3358 int data_size;
3359 struct breakpoint *tp;
3360 off_t offset, tframe_offset;
3361 ULONGEST tfaddr;
3362
3363 lseek (trace_fd, trace_frames_offset, SEEK_SET);
3364 offset = trace_frames_offset;
3365 while (1)
3366 {
3367 tframe_offset = offset;
3368 gotten = read (trace_fd, &tpnum, 2);
3369 if (gotten < 0)
3370 perror_with_name (trace_filename);
3371 else if (gotten < 2)
3372 error (_("Premature end of file while reading trace file"));
3373 offset += 2;
3374 if (tpnum == 0)
3375 break;
3376 gotten = read (trace_fd, &data_size, 4);
3377 if (gotten < 0)
3378 perror_with_name (trace_filename);
3379 else if (gotten < 4)
3380 error (_("Premature end of file while reading trace file"));
3381 offset += 4;
3382 switch (type)
3383 {
3384 case tfind_number:
3385 if (tfnum == num)
3386 found = 1;
3387 break;
3388 case tfind_pc:
3389 tfaddr = tfile_get_traceframe_address (tframe_offset);
3390 if (tfaddr == addr1)
3391 found = 1;
3392 break;
3393 case tfind_tp:
3394 tp = get_tracepoint (num);
3395 if (tp && tpnum == tp->number_on_target)
3396 found = 1;
3397 break;
3398 case tfind_range:
3399 tfaddr = tfile_get_traceframe_address (tframe_offset);
3400 if (addr1 <= tfaddr && tfaddr <= addr2)
3401 found = 1;
3402 break;
3403 case tfind_outside:
3404 tfaddr = tfile_get_traceframe_address (tframe_offset);
3405 if (!(addr1 <= tfaddr && tfaddr <= addr2))
3406 found = 1;
3407 break;
3408 default:
3409 internal_error (__FILE__, __LINE__, _("unknown tfind type"));
3410 }
3411 if (found)
3412 {
3413 printf_filtered ("Found traceframe %d.\n", tfnum);
3414 if (tpp)
3415 *tpp = tpnum;
3416 cur_offset = offset;
3417 cur_data_size = data_size;
3418 return tfnum;
3419 }
3420 /* Skip past the traceframe's data. */
3421 lseek (trace_fd, data_size, SEEK_CUR);
3422 offset += data_size;
3423 /* Update our own count of traceframes. */
3424 ++tfnum;
3425 }
3426 /* Did not find what we were looking for. */
3427 if (tpp)
3428 *tpp = -1;
3429 return -1;
3430 }
3431
3432 /* Look for a block of saved registers in the traceframe, and get the
3433 requested register from it. */
3434
3435 static void
3436 tfile_fetch_registers (struct target_ops *ops,
3437 struct regcache *regcache, int regno)
3438 {
3439 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3440 char block_type;
3441 int i, pos, offset, regn, regsize, gotten;
3442 unsigned short mlen;
3443 char *regs;
3444
3445 /* An uninitialized reg size says we're not going to be
3446 successful at getting register blocks. */
3447 if (!trace_regblock_size)
3448 return;
3449
3450 regs = alloca (trace_regblock_size);
3451
3452 lseek (trace_fd, cur_offset, SEEK_SET);
3453 pos = 0;
3454 while (pos < cur_data_size)
3455 {
3456 gotten = read (trace_fd, &block_type, 1);
3457 if (gotten < 0)
3458 perror_with_name (trace_filename);
3459 else if (gotten < 1)
3460 error (_("Premature end of file while reading trace file"));
3461
3462 ++pos;
3463 switch (block_type)
3464 {
3465 case 'R':
3466 gotten = read (trace_fd, regs, trace_regblock_size);
3467 if (gotten < 0)
3468 perror_with_name (trace_filename);
3469 else if (gotten < trace_regblock_size)
3470 error (_("Premature end of file while reading trace file"));
3471
3472 /* Assume the block is laid out in GDB register number order,
3473 each register with the size that it has in GDB. */
3474 offset = 0;
3475 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
3476 {
3477 regsize = register_size (gdbarch, regn);
3478 /* Make sure we stay within block bounds. */
3479 if (offset + regsize >= trace_regblock_size)
3480 break;
3481 if (!regcache_valid_p (regcache, regn))
3482 {
3483 if (regno == regn)
3484 {
3485 regcache_raw_supply (regcache, regno, regs + offset);
3486 break;
3487 }
3488 else if (regno == -1)
3489 {
3490 regcache_raw_supply (regcache, regn, regs + offset);
3491 }
3492 }
3493 offset += regsize;
3494 }
3495 return;
3496 case 'M':
3497 lseek (trace_fd, 8, SEEK_CUR);
3498 gotten = read (trace_fd, &mlen, 2);
3499 if (gotten < 0)
3500 perror_with_name (trace_filename);
3501 else if (gotten < 2)
3502 error (_("Premature end of file while reading trace file"));
3503 lseek (trace_fd, mlen, SEEK_CUR);
3504 pos += (8 + 2 + mlen);
3505 break;
3506 case 'V':
3507 lseek (trace_fd, 4 + 8, SEEK_CUR);
3508 pos += (4 + 8);
3509 break;
3510 default:
3511 error ("Unknown block type '%c' (0x%x) in trace frame",
3512 block_type, block_type);
3513 break;
3514 }
3515 }
3516 }
3517
3518 static LONGEST
3519 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
3520 const char *annex, gdb_byte *readbuf,
3521 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
3522 {
3523 char block_type;
3524 int pos, gotten;
3525 ULONGEST maddr;
3526 unsigned short mlen;
3527
3528 /* We're only doing regular memory for now. */
3529 if (object != TARGET_OBJECT_MEMORY)
3530 return -1;
3531
3532 if (readbuf == NULL)
3533 error ("tfile_xfer_partial: trace file is read-only");
3534
3535 lseek (trace_fd, cur_offset, SEEK_SET);
3536 pos = 0;
3537 while (pos < cur_data_size)
3538 {
3539 gotten = read (trace_fd, &block_type, 1);
3540 if (gotten < 0)
3541 perror_with_name (trace_filename);
3542 else if (gotten < 1)
3543 error (_("Premature end of file while reading trace file"));
3544 ++pos;
3545 switch (block_type)
3546 {
3547 case 'R':
3548 lseek (trace_fd, trace_regblock_size, SEEK_CUR);
3549 pos += trace_regblock_size;
3550 break;
3551 case 'M':
3552 gotten = read (trace_fd, &maddr, 8);
3553 if (gotten < 0)
3554 perror_with_name (trace_filename);
3555 else if (gotten < 8)
3556 error (_("Premature end of file while reading trace file"));
3557
3558 gotten = read (trace_fd, &mlen, 2);
3559 if (gotten < 0)
3560 perror_with_name (trace_filename);
3561 else if (gotten < 2)
3562 error (_("Premature end of file while reading trace file"));
3563 if (maddr <= offset && (offset + len) <= (maddr + mlen))
3564 {
3565 gotten = read (trace_fd, readbuf, mlen);
3566 if (gotten < 0)
3567 perror_with_name (trace_filename);
3568 else if (gotten < mlen)
3569 error (_("Premature end of file qwhile reading trace file"));
3570
3571 return mlen;
3572 }
3573 lseek (trace_fd, mlen, SEEK_CUR);
3574 pos += (8 + 2 + mlen);
3575 break;
3576 case 'V':
3577 lseek (trace_fd, 4 + 8, SEEK_CUR);
3578 pos += (4 + 8);
3579 break;
3580 default:
3581 error ("Unknown block type '%c' (0x%x) in traceframe",
3582 block_type, block_type);
3583 break;
3584 }
3585 }
3586 /* Indicate failure to find the requested memory block. */
3587 return -1;
3588 }
3589
3590 /* Iterate through the blocks of a trace frame, looking for a 'V'
3591 block with a matching tsv number. */
3592
3593 static int
3594 tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
3595 {
3596 char block_type;
3597 int pos, vnum, gotten;
3598 unsigned short mlen;
3599
3600 lseek (trace_fd, cur_offset, SEEK_SET);
3601 pos = 0;
3602 while (pos < cur_data_size)
3603 {
3604 gotten = read (trace_fd, &block_type, 1);
3605 if (gotten < 0)
3606 perror_with_name (trace_filename);
3607 else if (gotten < 1)
3608 error (_("Premature end of file while reading trace file"));
3609 ++pos;
3610 switch (block_type)
3611 {
3612 case 'R':
3613 lseek (trace_fd, trace_regblock_size, SEEK_CUR);
3614 pos += trace_regblock_size;
3615 break;
3616 case 'M':
3617 lseek (trace_fd, 8, SEEK_CUR);
3618 gotten = read (trace_fd, &mlen, 2);
3619 if (gotten < 0)
3620 perror_with_name (trace_filename);
3621 else if (gotten < 2)
3622 error (_("Premature end of file while reading trace file"));
3623 lseek (trace_fd, mlen, SEEK_CUR);
3624 pos += (8 + 2 + mlen);
3625 break;
3626 case 'V':
3627 gotten = read (trace_fd, &vnum, 4);
3628 if (gotten < 0)
3629 perror_with_name (trace_filename);
3630 else if (gotten < 4)
3631 error (_("Premature end of file while reading trace file"));
3632 if (tsvnum == vnum)
3633 {
3634 gotten = read (trace_fd, val, 8);
3635 if (gotten < 0)
3636 perror_with_name (trace_filename);
3637 else if (gotten < 8)
3638 error (_("Premature end of file while reading trace file"));
3639 return 1;
3640 }
3641 lseek (trace_fd, 8, SEEK_CUR);
3642 pos += (4 + 8);
3643 break;
3644 default:
3645 error ("Unknown block type '%c' (0x%x) in traceframe",
3646 block_type, block_type);
3647 break;
3648 }
3649 }
3650 /* Didn't find anything. */
3651 return 0;
3652 }
3653
3654 static int
3655 tfile_has_memory (struct target_ops *ops)
3656 {
3657 return 1;
3658 }
3659
3660 static int
3661 tfile_has_stack (struct target_ops *ops)
3662 {
3663 return 1;
3664 }
3665
3666 static int
3667 tfile_has_registers (struct target_ops *ops)
3668 {
3669 return 1;
3670 }
3671
3672 static void
3673 init_tfile_ops (void)
3674 {
3675 tfile_ops.to_shortname = "tfile";
3676 tfile_ops.to_longname = "Local trace dump file";
3677 tfile_ops.to_doc =
3678 "Use a trace file as a target. Specify the filename of the trace file.";
3679 tfile_ops.to_open = tfile_open;
3680 tfile_ops.to_close = tfile_close;
3681 tfile_ops.to_fetch_registers = tfile_fetch_registers;
3682 tfile_ops.to_xfer_partial = tfile_xfer_partial;
3683 tfile_ops.to_files_info = tfile_files_info;
3684 tfile_ops.to_get_trace_status = tfile_get_trace_status;
3685 tfile_ops.to_trace_find = tfile_trace_find;
3686 tfile_ops.to_get_trace_state_variable_value = tfile_get_trace_state_variable_value;
3687 /* core_stratum might seem more logical, but GDB doesn't like having
3688 more than one core_stratum vector. */
3689 tfile_ops.to_stratum = process_stratum;
3690 tfile_ops.to_has_memory = tfile_has_memory;
3691 tfile_ops.to_has_stack = tfile_has_stack;
3692 tfile_ops.to_has_registers = tfile_has_registers;
3693 tfile_ops.to_magic = OPS_MAGIC;
3694 }
3695
3696 /* module initialization */
3697 void
3698 _initialize_tracepoint (void)
3699 {
3700 struct cmd_list_element *c;
3701
3702 traceframe_number = -1;
3703 tracepoint_number = -1;
3704
3705 if (tracepoint_list.list == NULL)
3706 {
3707 tracepoint_list.listsize = 128;
3708 tracepoint_list.list = xmalloc
3709 (tracepoint_list.listsize * sizeof (struct memrange));
3710 }
3711 if (tracepoint_list.aexpr_list == NULL)
3712 {
3713 tracepoint_list.aexpr_listsize = 128;
3714 tracepoint_list.aexpr_list = xmalloc
3715 (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
3716 }
3717
3718 if (stepping_list.list == NULL)
3719 {
3720 stepping_list.listsize = 128;
3721 stepping_list.list = xmalloc
3722 (stepping_list.listsize * sizeof (struct memrange));
3723 }
3724
3725 if (stepping_list.aexpr_list == NULL)
3726 {
3727 stepping_list.aexpr_listsize = 128;
3728 stepping_list.aexpr_list = xmalloc
3729 (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
3730 }
3731
3732 add_info ("scope", scope_info,
3733 _("List the variables local to a scope"));
3734
3735 add_cmd ("tracepoints", class_trace, NULL,
3736 _("Tracing of program execution without stopping the program."),
3737 &cmdlist);
3738
3739 add_com ("tdump", class_trace, trace_dump_command,
3740 _("Print everything collected at the current tracepoint."));
3741
3742 add_com ("tsave", class_trace, trace_save_command, _("\
3743 Save the trace data to a file.\n\
3744 Use the '-r' option to direct the target to save directly to the file,\n\
3745 using its own filesystem."));
3746
3747 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
3748 Define a trace state variable.\n\
3749 Argument is a $-prefixed name, optionally followed\n\
3750 by '=' and an expression that sets the initial value\n\
3751 at the start of tracing."));
3752 set_cmd_completer (c, expression_completer);
3753
3754 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
3755 Delete one or more trace state variables.\n\
3756 Arguments are the names of the variables to delete.\n\
3757 If no arguments are supplied, delete all variables."), &deletelist);
3758 /* FIXME add a trace variable completer */
3759
3760 add_info ("tvariables", tvariables_info, _("\
3761 Status of trace state variables and their values.\n\
3762 "));
3763
3764 add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
3765 Select a trace frame;\n\
3766 No argument means forward by one frame; '-' means backward by one frame."),
3767 &tfindlist, "tfind ", 1, &cmdlist);
3768
3769 add_cmd ("outside", class_trace, trace_find_outside_command, _("\
3770 Select a trace frame whose PC is outside the given range (exclusive).\n\
3771 Usage: tfind outside addr1, addr2"),
3772 &tfindlist);
3773
3774 add_cmd ("range", class_trace, trace_find_range_command, _("\
3775 Select a trace frame whose PC is in the given range (inclusive).\n\
3776 Usage: tfind range addr1,addr2"),
3777 &tfindlist);
3778
3779 add_cmd ("line", class_trace, trace_find_line_command, _("\
3780 Select a trace frame by source line.\n\
3781 Argument can be a line number (with optional source file), \n\
3782 a function name, or '*' followed by an address.\n\
3783 Default argument is 'the next source line that was traced'."),
3784 &tfindlist);
3785
3786 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
3787 Select a trace frame by tracepoint number.\n\
3788 Default is the tracepoint for the current trace frame."),
3789 &tfindlist);
3790
3791 add_cmd ("pc", class_trace, trace_find_pc_command, _("\
3792 Select a trace frame by PC.\n\
3793 Default is the current PC, or the PC of the current trace frame."),
3794 &tfindlist);
3795
3796 add_cmd ("end", class_trace, trace_find_end_command, _("\
3797 Synonym for 'none'.\n\
3798 De-select any trace frame and resume 'live' debugging."),
3799 &tfindlist);
3800
3801 add_cmd ("none", class_trace, trace_find_none_command,
3802 _("De-select any trace frame and resume 'live' debugging."),
3803 &tfindlist);
3804
3805 add_cmd ("start", class_trace, trace_find_start_command,
3806 _("Select the first trace frame in the trace buffer."),
3807 &tfindlist);
3808
3809 add_com ("tstatus", class_trace, trace_status_command,
3810 _("Display the status of the current trace data collection."));
3811
3812 add_com ("tstop", class_trace, trace_stop_command,
3813 _("Stop trace data collection."));
3814
3815 add_com ("tstart", class_trace, trace_start_command,
3816 _("Start trace data collection."));
3817
3818 add_com ("end", class_trace, end_actions_pseudocommand, _("\
3819 Ends a list of commands or actions.\n\
3820 Several GDB commands allow you to enter a list of commands or actions.\n\
3821 Entering \"end\" on a line by itself is the normal way to terminate\n\
3822 such a list.\n\n\
3823 Note: the \"end\" command cannot be used at the gdb prompt."));
3824
3825 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
3826 Specify single-stepping behavior at a tracepoint.\n\
3827 Argument is number of instructions to trace in single-step mode\n\
3828 following the tracepoint. This command is normally followed by\n\
3829 one or more \"collect\" commands, to specify what to collect\n\
3830 while single-stepping.\n\n\
3831 Note: this command can only be used in a tracepoint \"actions\" list."));
3832
3833 add_com_alias ("ws", "while-stepping", class_alias, 0);
3834 add_com_alias ("stepping", "while-stepping", class_alias, 0);
3835
3836 add_com ("collect", class_trace, collect_pseudocommand, _("\
3837 Specify one or more data items to be collected at a tracepoint.\n\
3838 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
3839 collect all data (variables, registers) referenced by that expression.\n\
3840 Also accepts the following special arguments:\n\
3841 $regs -- all registers.\n\
3842 $args -- all function arguments.\n\
3843 $locals -- all variables local to the block/function scope.\n\
3844 Note: this command can only be used in a tracepoint \"actions\" list."));
3845
3846 add_com ("teval", class_trace, teval_pseudocommand, _("\
3847 Specify one or more expressions to be evaluated at a tracepoint.\n\
3848 Accepts a comma-separated list of (one or more) expressions.\n\
3849 The result of each evaluation will be discarded.\n\
3850 Note: this command can only be used in a tracepoint \"actions\" list."));
3851
3852 add_com ("actions", class_trace, trace_actions_command, _("\
3853 Specify the actions to be taken at a tracepoint.\n\
3854 Tracepoint actions may include collecting of specified data, \n\
3855 single-stepping, or enabling/disabling other tracepoints, \n\
3856 depending on target's capabilities."));
3857
3858 default_collect = xstrdup ("");
3859 add_setshow_string_cmd ("default-collect", class_trace,
3860 &default_collect, _("\
3861 Set the list of expressions to collect by default"), _("\
3862 Show the list of expressions to collect by default"), NULL,
3863 NULL, NULL,
3864 &setlist, &showlist);
3865
3866 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
3867 &disconnected_tracing, _("\
3868 Set whether tracing continues after GDB disconnects."), _("\
3869 Show whether tracing continues after GDB disconnects."), _("\
3870 Use this to continue a tracing run even if GDB disconnects\n\
3871 or detaches from the target. You can reconnect later and look at\n\
3872 trace data collected in the meantime."),
3873 set_disconnected_tracing,
3874 NULL,
3875 &setlist,
3876 &showlist);
3877
3878 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
3879 &circular_trace_buffer, _("\
3880 Set target's use of circular trace buffer."), _("\
3881 Show target's use of circular trace buffer."), _("\
3882 Use this to make the trace buffer into a circular buffer,\n\
3883 which will discard traceframes (oldest first) instead of filling\n\
3884 up and stopping the trace run."),
3885 set_circular_trace_buffer,
3886 NULL,
3887 &setlist,
3888 &showlist);
3889
3890 init_tfile_ops ();
3891
3892 add_target (&tfile_ops);
3893 }