2001-08-23 Martin M. Hunt <hunt@redhat.com>
[deliverable/binutils-gdb.git] / gdb / tracepoint.c
CommitLineData
c906108c 1/* Tracing functionality for remote targets in custom GDB protocol
b6ba6518 2 Copyright 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
c906108c 3
c5aa993b 4 This file is part of GDB.
c906108c 5
c5aa993b
JM
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
c906108c 10
c5aa993b
JM
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
c906108c 15
c5aa993b
JM
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
c906108c
SS
20
21#include "defs.h"
22#include "symtab.h"
23#include "frame.h"
c906108c
SS
24#include "gdbtypes.h"
25#include "expression.h"
26#include "gdbcmd.h"
27#include "value.h"
28#include "target.h"
29#include "language.h"
30#include "gdb_string.h"
104c1213
JM
31#include "inferior.h"
32#include "tracepoint.h"
c2c6d25f 33#include "remote.h"
c5f0f3d0 34#include "linespec.h"
4e052eda 35#include "regcache.h"
c94fdfd0 36#include "completer.h"
8f45b7fe 37#include "gdb-events.h"
c906108c
SS
38
39#include "ax.h"
40#include "ax-gdb.h"
41
42/* readline include files */
43#include <readline/readline.h>
44#include <readline/history.h>
45
46/* readline defines this. */
47#undef savestring
48
49#ifdef HAVE_UNISTD_H
50#include <unistd.h>
51#endif
52
53/* maximum length of an agent aexpression.
54 this accounts for the fact that packets are limited to 400 bytes
55 (which includes everything -- including the checksum), and assumes
56 the worst case of maximum length for each of the pieces of a
57 continuation packet.
c5aa993b 58
c906108c
SS
59 NOTE: expressions get mem2hex'ed otherwise this would be twice as
60 large. (400 - 31)/2 == 184 */
61#define MAX_AGENT_EXPR_LEN 184
62
63
64extern int info_verbose;
507f3c78
KB
65extern void (*readline_begin_hook) (char *, ...);
66extern char *(*readline_hook) (char *);
67extern void (*readline_end_hook) (void);
a14ed312 68extern void x_command (char *, int);
c5aa993b 69extern int addressprint; /* Print machine addresses? */
c906108c 70
104c1213
JM
71/* GDB commands implemented in other modules:
72 */
73
a14ed312
KB
74extern void output_command (char *, int);
75extern void registers_info (char *, int);
76extern void args_info (char *, int);
77extern void locals_info (char *, int);
104c1213
JM
78
79
c906108c
SS
80/* If this definition isn't overridden by the header files, assume
81 that isatty and fileno exist on this system. */
82#ifndef ISATTY
83#define ISATTY(FP) (isatty (fileno (FP)))
84#endif
85
86/*
87 Tracepoint.c:
88
89 This module defines the following debugger commands:
90 trace : set a tracepoint on a function, line, or address.
91 info trace : list all debugger-defined tracepoints.
92 delete trace : delete one or more tracepoints.
93 enable trace : enable one or more tracepoints.
94 disable trace : disable one or more tracepoints.
95 actions : specify actions to be taken at a tracepoint.
96 passcount : specify a pass count for a tracepoint.
97 tstart : start a trace experiment.
98 tstop : stop a trace experiment.
99 tstatus : query the status of a trace experiment.
100 tfind : find a trace frame in the trace buffer.
101 tdump : print everything collected at the current tracepoint.
102 save-tracepoints : write tracepoint setup into a file.
103
104 This module defines the following user-visible debugger variables:
105 $trace_frame : sequence number of trace frame currently being debugged.
106 $trace_line : source line of trace frame currently being debugged.
107 $trace_file : source file of trace frame currently being debugged.
108 $tracepoint : tracepoint number of trace frame currently being debugged.
c5aa993b 109 */
c906108c
SS
110
111
112/* ======= Important global variables: ======= */
113
114/* Chain of all tracepoints defined. */
115struct tracepoint *tracepoint_chain;
116
117/* Number of last tracepoint made. */
118static int tracepoint_count;
119
120/* Number of last traceframe collected. */
121static int traceframe_number;
122
123/* Tracepoint for last traceframe collected. */
124static int tracepoint_number;
125
126/* Symbol for function for last traceframe collected */
127static struct symbol *traceframe_fun;
128
129/* Symtab and line for last traceframe collected */
130static struct symtab_and_line traceframe_sal;
131
132/* Tracing command lists */
133static struct cmd_list_element *tfindlist;
134
135/* ======= Important command functions: ======= */
a14ed312
KB
136static void trace_command (char *, int);
137static void tracepoints_info (char *, int);
138static void delete_trace_command (char *, int);
139static void enable_trace_command (char *, int);
140static void disable_trace_command (char *, int);
141static void trace_pass_command (char *, int);
142static void trace_actions_command (char *, int);
143static void trace_start_command (char *, int);
144static void trace_stop_command (char *, int);
145static void trace_status_command (char *, int);
146static void trace_find_command (char *, int);
147static void trace_find_pc_command (char *, int);
148static void trace_find_tracepoint_command (char *, int);
149static void trace_find_line_command (char *, int);
150static void trace_find_range_command (char *, int);
151static void trace_find_outside_command (char *, int);
152static void tracepoint_save_command (char *, int);
153static void trace_dump_command (char *, int);
c906108c
SS
154
155/* support routines */
a14ed312 156static void trace_mention (struct tracepoint *);
c906108c
SS
157
158struct collection_list;
a14ed312 159static void add_aexpr (struct collection_list *, struct agent_expr *);
c5aa993b 160static unsigned char *mem2hex (unsigned char *, unsigned char *, int);
a14ed312
KB
161static void add_register (struct collection_list *collection,
162 unsigned int regno);
74b7792f 163static struct cleanup *make_cleanup_free_actions (struct tracepoint *t);
a14ed312
KB
164static void free_actions_list (char **actions_list);
165static void free_actions_list_cleanup_wrapper (void *);
392a587b 166
a14ed312 167extern void _initialize_tracepoint (void);
c906108c
SS
168
169/* Utility: returns true if "target remote" */
170static int
fba45db2 171target_is_remote (void)
c906108c
SS
172{
173 if (current_target.to_shortname &&
174 strcmp (current_target.to_shortname, "remote") == 0)
175 return 1;
176 else
177 return 0;
178}
179
180/* Utility: generate error from an incoming stub packet. */
c5aa993b 181static void
fba45db2 182trace_error (char *buf)
c906108c
SS
183{
184 if (*buf++ != 'E')
185 return; /* not an error msg */
c5aa993b 186 switch (*buf)
c906108c
SS
187 {
188 case '1': /* malformed packet error */
189 if (*++buf == '0') /* general case: */
190 error ("tracepoint.c: error in outgoing packet.");
191 else
c5aa993b 192 error ("tracepoint.c: error in outgoing packet at field #%d.",
c906108c
SS
193 strtol (buf, NULL, 16));
194 case '2':
195 error ("trace API error 0x%s.", ++buf);
196 default:
197 error ("Target returns error code '%s'.", buf);
198 }
199}
200
201/* Utility: wait for reply from stub, while accepting "O" packets */
202static char *
c2d11a7d
JM
203remote_get_noisy_reply (char *buf,
204 long sizeof_buf)
c906108c 205{
c5aa993b 206 do /* loop on reply from remote stub */
c906108c 207 {
c5aa993b 208 QUIT; /* allow user to bail out with ^C */
c2d11a7d 209 getpkt (buf, sizeof_buf, 0);
c906108c
SS
210 if (buf[0] == 0)
211 error ("Target does not support this command.");
212 else if (buf[0] == 'E')
213 trace_error (buf);
214 else if (buf[0] == 'O' &&
215 buf[1] != 'K')
216 remote_console_output (buf + 1); /* 'O' message from stub */
217 else
c5aa993b
JM
218 return buf; /* here's the actual reply */
219 }
220 while (1);
c906108c
SS
221}
222
223/* Set tracepoint count to NUM. */
224static void
fba45db2 225set_tracepoint_count (int num)
c906108c
SS
226{
227 tracepoint_count = num;
228 set_internalvar (lookup_internalvar ("tpnum"),
229 value_from_longest (builtin_type_int, (LONGEST) num));
230}
231
232/* Set traceframe number to NUM. */
233static void
fba45db2 234set_traceframe_num (int num)
c906108c
SS
235{
236 traceframe_number = num;
237 set_internalvar (lookup_internalvar ("trace_frame"),
238 value_from_longest (builtin_type_int, (LONGEST) num));
239}
240
241/* Set tracepoint number to NUM. */
242static void
fba45db2 243set_tracepoint_num (int num)
c906108c
SS
244{
245 tracepoint_number = num;
246 set_internalvar (lookup_internalvar ("tracepoint"),
247 value_from_longest (builtin_type_int, (LONGEST) num));
248}
249
250/* Set externally visible debug variables for querying/printing
251 the traceframe context (line, function, file) */
252
253static void
fba45db2 254set_traceframe_context (CORE_ADDR trace_pc)
c906108c
SS
255{
256 static struct type *func_string, *file_string;
c5aa993b
JM
257 static struct type *func_range, *file_range;
258 static value_ptr func_val, file_val;
c906108c
SS
259 static struct type *charstar;
260 int len;
261
262 if (charstar == (struct type *) NULL)
263 charstar = lookup_pointer_type (builtin_type_char);
264
c5aa993b 265 if (trace_pc == -1) /* cease debugging any trace buffers */
c906108c
SS
266 {
267 traceframe_fun = 0;
268 traceframe_sal.pc = traceframe_sal.line = 0;
269 traceframe_sal.symtab = NULL;
c5aa993b 270 set_internalvar (lookup_internalvar ("trace_func"),
4478b372 271 value_from_pointer (charstar, (LONGEST) 0));
c5aa993b 272 set_internalvar (lookup_internalvar ("trace_file"),
4478b372 273 value_from_pointer (charstar, (LONGEST) 0));
c906108c 274 set_internalvar (lookup_internalvar ("trace_line"),
4478b372 275 value_from_pointer (builtin_type_int, (LONGEST) - 1));
c906108c
SS
276 return;
277 }
278
279 /* save as globals for internal use */
280 traceframe_sal = find_pc_line (trace_pc, 0);
281 traceframe_fun = find_pc_function (trace_pc);
282
283 /* save linenumber as "$trace_line", a debugger variable visible to users */
284 set_internalvar (lookup_internalvar ("trace_line"),
c5aa993b 285 value_from_longest (builtin_type_int,
c906108c
SS
286 (LONGEST) traceframe_sal.line));
287
288 /* save func name as "$trace_func", a debugger variable visible to users */
c5aa993b 289 if (traceframe_fun == NULL ||
c906108c 290 SYMBOL_NAME (traceframe_fun) == NULL)
c5aa993b 291 set_internalvar (lookup_internalvar ("trace_func"),
4478b372 292 value_from_pointer (charstar, (LONGEST) 0));
c906108c
SS
293 else
294 {
295 len = strlen (SYMBOL_NAME (traceframe_fun));
c5aa993b
JM
296 func_range = create_range_type (func_range,
297 builtin_type_int, 0, len - 1);
298 func_string = create_array_type (func_string,
c906108c
SS
299 builtin_type_char, func_range);
300 func_val = allocate_value (func_string);
301 VALUE_TYPE (func_val) = func_string;
c5aa993b
JM
302 memcpy (VALUE_CONTENTS_RAW (func_val),
303 SYMBOL_NAME (traceframe_fun),
c906108c
SS
304 len);
305 func_val->modifiable = 0;
306 set_internalvar (lookup_internalvar ("trace_func"), func_val);
307 }
308
309 /* save file name as "$trace_file", a debugger variable visible to users */
c5aa993b 310 if (traceframe_sal.symtab == NULL ||
c906108c 311 traceframe_sal.symtab->filename == NULL)
c5aa993b 312 set_internalvar (lookup_internalvar ("trace_file"),
4478b372 313 value_from_pointer (charstar, (LONGEST) 0));
c906108c
SS
314 else
315 {
316 len = strlen (traceframe_sal.symtab->filename);
c5aa993b
JM
317 file_range = create_range_type (file_range,
318 builtin_type_int, 0, len - 1);
319 file_string = create_array_type (file_string,
c906108c
SS
320 builtin_type_char, file_range);
321 file_val = allocate_value (file_string);
322 VALUE_TYPE (file_val) = file_string;
c5aa993b
JM
323 memcpy (VALUE_CONTENTS_RAW (file_val),
324 traceframe_sal.symtab->filename,
c906108c
SS
325 len);
326 file_val->modifiable = 0;
327 set_internalvar (lookup_internalvar ("trace_file"), file_val);
328 }
329}
330
331/* Low level routine to set a tracepoint.
332 Returns the tracepoint object so caller can set other things.
333 Does not set the tracepoint number!
334 Does not print anything.
335
336 ==> This routine should not be called if there is a chance of later
337 error(); otherwise it leaves a bogus tracepoint on the chain. Validate
338 your arguments BEFORE calling this routine! */
339
340static struct tracepoint *
fba45db2 341set_raw_tracepoint (struct symtab_and_line sal)
c906108c
SS
342{
343 register struct tracepoint *t, *tc;
344 struct cleanup *old_chain;
345
346 t = (struct tracepoint *) xmalloc (sizeof (struct tracepoint));
b8c9b27d 347 old_chain = make_cleanup (xfree, t);
c906108c
SS
348 memset (t, 0, sizeof (*t));
349 t->address = sal.pc;
350 if (sal.symtab == NULL)
351 t->source_file = NULL;
352 else
c5aa993b 353 t->source_file = savestring (sal.symtab->filename,
c906108c
SS
354 strlen (sal.symtab->filename));
355
c5aa993b
JM
356 t->section = sal.section;
357 t->language = current_language->la_language;
c906108c
SS
358 t->input_radix = input_radix;
359 t->line_number = sal.line;
b5de0fa7 360 t->enabled_p = 1;
c5aa993b
JM
361 t->next = 0;
362 t->step_count = 0;
363 t->pass_count = 0;
c906108c
SS
364 t->addr_string = NULL;
365
366 /* Add this tracepoint to the end of the chain
367 so that a list of tracepoints will come out in order
368 of increasing numbers. */
369
370 tc = tracepoint_chain;
371 if (tc == 0)
372 tracepoint_chain = t;
373 else
374 {
375 while (tc->next)
376 tc = tc->next;
377 tc->next = t;
378 }
379 discard_cleanups (old_chain);
380 return t;
381}
382
383/* Set a tracepoint according to ARG (function, linenum or *address) */
384static void
fba45db2 385trace_command (char *arg, int from_tty)
c906108c 386{
c5aa993b 387 char **canonical = (char **) NULL;
c906108c
SS
388 struct symtabs_and_lines sals;
389 struct symtab_and_line sal;
390 struct tracepoint *t;
391 char *addr_start = 0, *addr_end = 0;
392 int i;
393
394 if (!arg || !*arg)
395 error ("trace command requires an argument");
396
397 if (from_tty && info_verbose)
398 printf_filtered ("TRACE %s\n", arg);
399
400 addr_start = arg;
c5aa993b
JM
401 sals = decode_line_1 (&arg, 1, (struct symtab *) NULL, 0, &canonical);
402 addr_end = arg;
403 if (!sals.nelts)
404 return; /* ??? Presumably decode_line_1 has already warned? */
c906108c
SS
405
406 /* Resolve all line numbers to PC's */
407 for (i = 0; i < sals.nelts; i++)
408 resolve_sal_pc (&sals.sals[i]);
409
410 /* Now set all the tracepoints. */
411 for (i = 0; i < sals.nelts; i++)
412 {
413 sal = sals.sals[i];
414
415 t = set_raw_tracepoint (sal);
416 set_tracepoint_count (tracepoint_count + 1);
417 t->number = tracepoint_count;
418
419 /* If a canonical line spec is needed use that instead of the
c5aa993b
JM
420 command string. */
421 if (canonical != (char **) NULL && canonical[i] != NULL)
c906108c
SS
422 t->addr_string = canonical[i];
423 else if (addr_start)
424 t->addr_string = savestring (addr_start, addr_end - addr_start);
425
426 trace_mention (t);
c906108c
SS
427 }
428
429 if (sals.nelts > 1)
430 {
431 printf_filtered ("Multiple tracepoints were set.\n");
432 printf_filtered ("Use 'delete trace' to delete unwanted tracepoints.\n");
433 }
434}
435
436/* Tell the user we have just set a tracepoint TP. */
437
438static void
fba45db2 439trace_mention (struct tracepoint *tp)
c906108c
SS
440{
441 printf_filtered ("Tracepoint %d", tp->number);
442
443 if (addressprint || (tp->source_file == NULL))
444 {
445 printf_filtered (" at ");
446 print_address_numeric (tp->address, 1, gdb_stdout);
447 }
448 if (tp->source_file)
449 printf_filtered (": file %s, line %d.",
450 tp->source_file, tp->line_number);
451
452 printf_filtered ("\n");
453}
454
455/* Print information on tracepoint number TPNUM_EXP, or all if omitted. */
456
457static void
fba45db2 458tracepoints_info (char *tpnum_exp, int from_tty)
c906108c
SS
459{
460 struct tracepoint *t;
461 struct action_line *action;
462 int found_a_tracepoint = 0;
463 char wrap_indent[80];
464 struct symbol *sym;
465 int tpnum = -1;
466
467 if (tpnum_exp)
bb518678 468 tpnum = parse_and_eval_long (tpnum_exp);
c906108c
SS
469
470 ALL_TRACEPOINTS (t)
471 if (tpnum == -1 || tpnum == t->number)
c5aa993b
JM
472 {
473 extern int addressprint; /* print machine addresses? */
c906108c 474
c5aa993b
JM
475 if (!found_a_tracepoint++)
476 {
477 printf_filtered ("Num Enb ");
478 if (addressprint)
75ac9d7b
MS
479 {
480 if (TARGET_ADDR_BIT <= 32)
481 printf_filtered ("Address ");
482 else
483 printf_filtered ("Address ");
484 }
c5aa993b
JM
485 printf_filtered ("PassC StepC What\n");
486 }
487 strcpy (wrap_indent, " ");
488 if (addressprint)
75ac9d7b
MS
489 {
490 if (TARGET_ADDR_BIT <= 32)
491 strcat (wrap_indent, " ");
492 else
493 strcat (wrap_indent, " ");
494 }
c5aa993b
JM
495
496 printf_filtered ("%-3d %-3s ", t->number,
b5de0fa7 497 t->enabled_p ? "y" : "n");
c5aa993b 498 if (addressprint)
75ac9d7b
MS
499 {
500 char *tmp;
501
502 if (TARGET_ADDR_BIT <= 32)
503 tmp = longest_local_hex_string_custom (t->address
504 & (CORE_ADDR) 0xffffffff,
505 "08l");
506 else
507 tmp = longest_local_hex_string_custom (t->address, "016l");
508
509 printf_filtered ("%s ", tmp);
510 }
c4093a6a 511 printf_filtered ("%-5d %-5ld ", t->pass_count, t->step_count);
c5aa993b
JM
512
513 if (t->source_file)
514 {
515 sym = find_pc_sect_function (t->address, t->section);
516 if (sym)
517 {
518 fputs_filtered ("in ", gdb_stdout);
519 fputs_filtered (SYMBOL_SOURCE_NAME (sym), gdb_stdout);
520 wrap_here (wrap_indent);
521 fputs_filtered (" at ", gdb_stdout);
522 }
523 fputs_filtered (t->source_file, gdb_stdout);
524 printf_filtered (":%d", t->line_number);
525 }
526 else
527 print_address_symbolic (t->address, gdb_stdout, demangle, " ");
c906108c 528
c5aa993b
JM
529 printf_filtered ("\n");
530 if (t->actions)
531 {
532 printf_filtered (" Actions for tracepoint %d: \n", t->number);
533 for (action = t->actions; action; action = action->next)
534 {
535 printf_filtered ("\t%s\n", action->action);
536 }
537 }
538 }
c906108c
SS
539 if (!found_a_tracepoint)
540 {
541 if (tpnum == -1)
c5aa993b 542 printf_filtered ("No tracepoints.\n");
c906108c 543 else
c5aa993b 544 printf_filtered ("No tracepoint number %d.\n", tpnum);
c906108c
SS
545 }
546}
547
548/* Optimization: the code to parse an enable, disable, or delete TP command
549 is virtually identical except for whether it performs an enable, disable,
550 or delete. Therefore I've combined them into one function with an opcode.
c5aa993b
JM
551 */
552enum tracepoint_opcode
c906108c 553{
104c1213
JM
554 enable_op,
555 disable_op,
556 delete_op
c906108c
SS
557};
558
104c1213 559/* This function implements enable, disable and delete commands. */
c906108c 560static void
fba45db2
KB
561tracepoint_operation (struct tracepoint *t, int from_tty,
562 enum tracepoint_opcode opcode)
c906108c
SS
563{
564 struct tracepoint *t2;
565
5c44784c
JM
566 if (t == NULL) /* no tracepoint operand */
567 return;
568
c5aa993b
JM
569 switch (opcode)
570 {
104c1213 571 case enable_op:
b5de0fa7 572 t->enabled_p = 1;
8f45b7fe 573 tracepoint_modify_event (t->number);
c5aa993b 574 break;
104c1213 575 case disable_op:
b5de0fa7 576 t->enabled_p = 0;
8f45b7fe 577 tracepoint_modify_event (t->number);
c5aa993b 578 break;
104c1213 579 case delete_op:
c5aa993b
JM
580 if (tracepoint_chain == t)
581 tracepoint_chain = t->next;
c906108c 582
c5aa993b
JM
583 ALL_TRACEPOINTS (t2)
584 if (t2->next == t)
c906108c 585 {
8f45b7fe 586 tracepoint_delete_event (t2->number);
c906108c
SS
587 t2->next = t->next;
588 break;
589 }
590
c5aa993b 591 if (t->addr_string)
b8c9b27d 592 xfree (t->addr_string);
c5aa993b 593 if (t->source_file)
b8c9b27d 594 xfree (t->source_file);
c5aa993b
JM
595 if (t->actions)
596 free_actions (t);
c906108c 597
b8c9b27d 598 xfree (t);
c5aa993b
JM
599 break;
600 }
c906108c
SS
601}
602
5c44784c 603/* Utility: parse a tracepoint number and look it up in the list.
c2d11a7d
JM
604 If MULTI_P is true, there might be a range of tracepoints in ARG.
605 if OPTIONAL_P is true, then if the argument is missing, the most
606 recent tracepoint (tracepoint_count) is returned. */
c906108c 607struct tracepoint *
fba45db2 608get_tracepoint_by_number (char **arg, int multi_p, int optional_p)
c906108c
SS
609{
610 struct tracepoint *t;
c906108c 611 int tpnum;
c2d11a7d 612 char *instring = arg == NULL ? NULL : *arg;
c906108c 613
c2d11a7d
JM
614 if (arg == NULL || *arg == NULL || ! **arg)
615 {
616 if (optional_p)
617 tpnum = tracepoint_count;
618 else
619 error_no_arg ("tracepoint number");
620 }
621 else
622 tpnum = multi_p ? get_number_or_range (arg) : get_number (arg);
c906108c 623
5c44784c 624 if (tpnum <= 0)
c906108c 625 {
c2d11a7d
JM
626 if (instring && *instring)
627 printf_filtered ("bad tracepoint number at or near '%s'\n", instring);
628 else
629 printf_filtered ("Tracepoint argument missing and no previous tracepoint\n");
5c44784c 630 return NULL;
c906108c 631 }
5c44784c 632
c906108c
SS
633 ALL_TRACEPOINTS (t)
634 if (t->number == tpnum)
c5aa993b
JM
635 {
636 return t;
637 }
5c44784c
JM
638
639 /* FIXME: if we are in the middle of a range we don't want to give
640 a message. The current interface to get_number_or_range doesn't
641 allow us to discover this. */
c906108c
SS
642 printf_unfiltered ("No tracepoint number %d.\n", tpnum);
643 return NULL;
644}
645
646/* Utility: parse a list of tracepoint numbers, and call a func for each. */
647static void
fba45db2
KB
648map_args_over_tracepoints (char *args, int from_tty,
649 enum tracepoint_opcode opcode)
c906108c
SS
650{
651 struct tracepoint *t, *tmp;
c906108c
SS
652
653 if (args == 0 || *args == 0) /* do them all */
654 ALL_TRACEPOINTS_SAFE (t, tmp)
655 tracepoint_operation (t, from_tty, opcode);
656 else
657 while (*args)
658 {
c5aa993b 659 QUIT; /* give user option to bail out with ^C */
c2d11a7d 660 t = get_tracepoint_by_number (&args, 1, 0);
5c44784c 661 tracepoint_operation (t, from_tty, opcode);
c906108c
SS
662 while (*args == ' ' || *args == '\t')
663 args++;
664 }
665}
666
667/* The 'enable trace' command enables tracepoints. Not supported by all targets. */
668static void
fba45db2 669enable_trace_command (char *args, int from_tty)
c906108c
SS
670{
671 dont_repeat ();
104c1213 672 map_args_over_tracepoints (args, from_tty, enable_op);
c906108c
SS
673}
674
675/* The 'disable trace' command enables tracepoints. Not supported by all targets. */
676static void
fba45db2 677disable_trace_command (char *args, int from_tty)
c906108c
SS
678{
679 dont_repeat ();
104c1213 680 map_args_over_tracepoints (args, from_tty, disable_op);
c906108c
SS
681}
682
683/* Remove a tracepoint (or all if no argument) */
684static void
fba45db2 685delete_trace_command (char *args, int from_tty)
c906108c
SS
686{
687 dont_repeat ();
688 if (!args || !*args) /* No args implies all tracepoints; */
689 if (from_tty) /* confirm only if from_tty... */
c5aa993b 690 if (tracepoint_chain) /* and if there are tracepoints to delete! */
c906108c
SS
691 if (!query ("Delete all tracepoints? "))
692 return;
693
104c1213 694 map_args_over_tracepoints (args, from_tty, delete_op);
c906108c
SS
695}
696
697/* Set passcount for tracepoint.
698
699 First command argument is passcount, second is tracepoint number.
700 If tracepoint number omitted, apply to most recently defined.
701 Also accepts special argument "all". */
702
703static void
fba45db2 704trace_pass_command (char *args, int from_tty)
c906108c
SS
705{
706 struct tracepoint *t1 = (struct tracepoint *) -1, *t2;
104c1213 707 unsigned int count;
5c44784c 708 int all = 0;
c906108c
SS
709
710 if (args == 0 || *args == 0)
c2d11a7d 711 error ("passcount command requires an argument (count + optional TP num)");
c906108c
SS
712
713 count = strtoul (args, &args, 10); /* count comes first, then TP num */
714
104c1213 715 while (*args && isspace ((int) *args))
c906108c
SS
716 args++;
717
718 if (*args && strncasecmp (args, "all", 3) == 0)
5c44784c
JM
719 {
720 args += 3; /* skip special argument "all" */
721 all = 1;
722 if (*args)
723 error ("Junk at end of arguments.");
724 }
c906108c 725 else
c2d11a7d 726 t1 = get_tracepoint_by_number (&args, 1, 1);
c906108c 727
5c44784c 728 do
c5aa993b 729 {
5c44784c
JM
730 if (t1)
731 {
732 ALL_TRACEPOINTS (t2)
733 if (t1 == (struct tracepoint *) -1 || t1 == t2)
734 {
735 t2->pass_count = count;
8f45b7fe 736 tracepoint_modify_event (t2->number);
5c44784c
JM
737 if (from_tty)
738 printf_filtered ("Setting tracepoint %d's passcount to %d\n",
739 t2->number, count);
740 }
c2d11a7d
JM
741 if (! all && *args)
742 t1 = get_tracepoint_by_number (&args, 1, 0);
5c44784c 743 }
c5aa993b 744 }
5c44784c 745 while (*args);
c906108c
SS
746}
747
748/* ACTIONS functions: */
749
750/* Prototypes for action-parsing utility commands */
a14ed312 751static void read_actions (struct tracepoint *);
c906108c
SS
752
753/* The three functions:
c5aa993b
JM
754 collect_pseudocommand,
755 while_stepping_pseudocommand, and
756 end_actions_pseudocommand
c906108c
SS
757 are placeholders for "commands" that are actually ONLY to be used
758 within a tracepoint action list. If the actual function is ever called,
759 it means that somebody issued the "command" at the top level,
760 which is always an error. */
761
c5aa993b 762static void
fba45db2 763end_actions_pseudocommand (char *args, int from_tty)
c906108c
SS
764{
765 error ("This command cannot be used at the top level.");
766}
767
768static void
fba45db2 769while_stepping_pseudocommand (char *args, int from_tty)
c906108c
SS
770{
771 error ("This command can only be used in a tracepoint actions list.");
772}
773
774static void
fba45db2 775collect_pseudocommand (char *args, int from_tty)
c906108c
SS
776{
777 error ("This command can only be used in a tracepoint actions list.");
778}
779
780/* Enter a list of actions for a tracepoint. */
781static void
fba45db2 782trace_actions_command (char *args, int from_tty)
c906108c
SS
783{
784 struct tracepoint *t;
c906108c
SS
785 char tmpbuf[128];
786 char *end_msg = "End with a line saying just \"end\".";
787
c2d11a7d 788 t = get_tracepoint_by_number (&args, 0, 1);
7a292a7a 789 if (t)
c906108c
SS
790 {
791 sprintf (tmpbuf, "Enter actions for tracepoint %d, one per line.",
792 t->number);
793
794 if (from_tty)
795 {
796 if (readline_begin_hook)
797 (*readline_begin_hook) ("%s %s\n", tmpbuf, end_msg);
798 else if (input_from_terminal_p ())
799 printf_filtered ("%s\n%s\n", tmpbuf, end_msg);
800 }
801
802 free_actions (t);
803 t->step_count = 0; /* read_actions may set this */
804 read_actions (t);
805
806 if (readline_end_hook)
807 (*readline_end_hook) ();
c906108c
SS
808 /* tracepoints_changed () */
809 }
5c44784c 810 /* else just return */
c906108c
SS
811}
812
813/* worker function */
814static void
fba45db2 815read_actions (struct tracepoint *t)
c906108c
SS
816{
817 char *line;
818 char *prompt1 = "> ", *prompt2 = " > ";
819 char *prompt = prompt1;
820 enum actionline_type linetype;
821 extern FILE *instream;
822 struct action_line *next = NULL, *temp;
823 struct cleanup *old_chain;
824
825 /* Control-C quits instantly if typed while in this loop
826 since it should not wait until the user types a newline. */
827 immediate_quit++;
828#ifdef STOP_SIGNAL
829 if (job_control)
0f71a2f6 830 {
6426a772 831 if (event_loop_p)
0f71a2f6
JM
832 signal (STOP_SIGNAL, handle_stop_sig);
833 else
834 signal (STOP_SIGNAL, stop_sig);
c5aa993b 835 }
c906108c 836#endif
74b7792f 837 old_chain = make_cleanup_free_actions (t);
c906108c
SS
838 while (1)
839 {
840 /* Make sure that all output has been output. Some machines may let
c5aa993b 841 you get away with leaving out some of the gdb_flush, but not all. */
c906108c
SS
842 wrap_here ("");
843 gdb_flush (gdb_stdout);
844 gdb_flush (gdb_stderr);
845
846 if (readline_hook && instream == NULL)
847 line = (*readline_hook) (prompt);
848 else if (instream == stdin && ISATTY (instream))
849 {
850 line = readline (prompt);
c5aa993b 851 if (line && *line) /* add it to command history */
c906108c
SS
852 add_history (line);
853 }
854 else
855 line = gdb_readline (0);
856
857 linetype = validate_actionline (&line, t);
858 if (linetype == BADLINE)
c5aa993b 859 continue; /* already warned -- collect another line */
c906108c
SS
860
861 temp = xmalloc (sizeof (struct action_line));
862 temp->next = NULL;
863 temp->action = line;
864
865 if (next == NULL) /* first action for this tracepoint? */
866 t->actions = next = temp;
867 else
868 {
869 next->next = temp;
870 next = temp;
871 }
872
873 if (linetype == STEPPING) /* begin "while-stepping" */
7a292a7a
SS
874 {
875 if (prompt == prompt2)
876 {
877 warning ("Already processing 'while-stepping'");
878 continue;
879 }
880 else
881 prompt = prompt2; /* change prompt for stepping actions */
882 }
c906108c 883 else if (linetype == END)
7a292a7a
SS
884 {
885 if (prompt == prompt2)
886 {
887 prompt = prompt1; /* end of single-stepping actions */
888 }
889 else
c5aa993b 890 { /* end of actions */
7a292a7a
SS
891 if (t->actions->next == NULL)
892 {
893 /* an "end" all by itself with no other actions means
894 this tracepoint has no actions. Discard empty list. */
895 free_actions (t);
896 }
897 break;
898 }
899 }
c906108c
SS
900 }
901#ifdef STOP_SIGNAL
902 if (job_control)
903 signal (STOP_SIGNAL, SIG_DFL);
904#endif
8edbea78 905 immediate_quit--;
c906108c
SS
906 discard_cleanups (old_chain);
907}
908
909/* worker function */
910enum actionline_type
fba45db2 911validate_actionline (char **line, struct tracepoint *t)
c906108c
SS
912{
913 struct cmd_list_element *c;
914 struct expression *exp = NULL;
c906108c
SS
915 struct cleanup *old_chain = NULL;
916 char *p;
917
104c1213 918 for (p = *line; isspace ((int) *p);)
c906108c
SS
919 p++;
920
921 /* symbol lookup etc. */
c5aa993b 922 if (*p == '\0') /* empty line: just prompt for another line. */
c906108c
SS
923 return BADLINE;
924
c5aa993b 925 if (*p == '#') /* comment line */
c906108c
SS
926 return GENERIC;
927
928 c = lookup_cmd (&p, cmdlist, "", -1, 1);
929 if (c == 0)
930 {
931 warning ("'%s' is not an action that I know, or is ambiguous.", p);
932 return BADLINE;
933 }
c5aa993b 934
c906108c
SS
935 if (c->function.cfunc == collect_pseudocommand)
936 {
937 struct agent_expr *aexpr;
938 struct agent_reqs areqs;
939
c5aa993b
JM
940 do
941 { /* repeat over a comma-separated list */
942 QUIT; /* allow user to bail out with ^C */
104c1213 943 while (isspace ((int) *p))
c5aa993b 944 p++;
c906108c 945
c5aa993b
JM
946 if (*p == '$') /* look for special pseudo-symbols */
947 {
c5aa993b
JM
948 if ((0 == strncasecmp ("reg", p + 1, 3)) ||
949 (0 == strncasecmp ("arg", p + 1, 3)) ||
950 (0 == strncasecmp ("loc", p + 1, 3)))
951 {
952 p = strchr (p, ',');
953 continue;
954 }
955 /* else fall thru, treat p as an expression and parse it! */
956 }
957 exp = parse_exp_1 (&p, block_for_pc (t->address), 1);
c13c43fd 958 old_chain = make_cleanup (free_current_contents, &exp);
c906108c 959
c5aa993b
JM
960 if (exp->elts[0].opcode == OP_VAR_VALUE)
961 {
962 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
963 {
104c1213 964 warning ("constant %s (value %ld) will not be collected.",
c5aa993b
JM
965 SYMBOL_NAME (exp->elts[2].symbol),
966 SYMBOL_VALUE (exp->elts[2].symbol));
967 return BADLINE;
968 }
969 else if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_OPTIMIZED_OUT)
970 {
971 warning ("%s is optimized away and cannot be collected.",
972 SYMBOL_NAME (exp->elts[2].symbol));
973 return BADLINE;
974 }
975 }
c906108c 976
c5aa993b
JM
977 /* we have something to collect, make sure that the expr to
978 bytecode translator can handle it and that it's not too long */
979 aexpr = gen_trace_for_expr (t->address, exp);
f23d52e0 980 make_cleanup_free_agent_expr (aexpr);
c906108c 981
c5aa993b
JM
982 if (aexpr->len > MAX_AGENT_EXPR_LEN)
983 error ("expression too complicated, try simplifying");
c906108c 984
c5aa993b 985 ax_reqs (aexpr, &areqs);
b8c9b27d 986 (void) make_cleanup (xfree, areqs.reg_mask);
c906108c 987
c5aa993b
JM
988 if (areqs.flaw != agent_flaw_none)
989 error ("malformed expression");
c906108c 990
c5aa993b
JM
991 if (areqs.min_height < 0)
992 error ("gdb: Internal error: expression has min height < 0");
c906108c 993
c5aa993b
JM
994 if (areqs.max_height > 20)
995 error ("expression too complicated, try simplifying");
c906108c 996
c5aa993b
JM
997 do_cleanups (old_chain);
998 }
999 while (p && *p++ == ',');
c906108c
SS
1000 return GENERIC;
1001 }
1002 else if (c->function.cfunc == while_stepping_pseudocommand)
1003 {
c5aa993b 1004 char *steparg; /* in case warning is necessary */
c906108c 1005
104c1213 1006 while (isspace ((int) *p))
c906108c
SS
1007 p++;
1008 steparg = p;
1009
1010 if (*p == '\0' ||
1011 (t->step_count = strtol (p, &p, 0)) == 0)
1012 {
104c1213 1013 warning ("'%s': bad step-count; command ignored.", *line);
c906108c
SS
1014 return BADLINE;
1015 }
1016 return STEPPING;
1017 }
1018 else if (c->function.cfunc == end_actions_pseudocommand)
1019 return END;
1020 else
1021 {
1022 warning ("'%s' is not a supported tracepoint action.", *line);
1023 return BADLINE;
1024 }
1025}
1026
1027/* worker function */
c5aa993b 1028void
fba45db2 1029free_actions (struct tracepoint *t)
c906108c
SS
1030{
1031 struct action_line *line, *next;
1032
1033 for (line = t->actions; line; line = next)
1034 {
1035 next = line->next;
c5aa993b 1036 if (line->action)
b8c9b27d
KB
1037 xfree (line->action);
1038 xfree (line);
c906108c
SS
1039 }
1040 t->actions = NULL;
1041}
1042
74b7792f
AC
1043static void
1044do_free_actions_cleanup (void *t)
1045{
1046 free_actions (t);
1047}
1048
1049static struct cleanup *
1050make_cleanup_free_actions (struct tracepoint *t)
1051{
1052 return make_cleanup (do_free_actions_cleanup, t);
1053}
1054
c5aa993b
JM
1055struct memrange
1056{
104c1213 1057 int type; /* 0 for absolute memory range, else basereg number */
c906108c
SS
1058 bfd_signed_vma start;
1059 bfd_signed_vma end;
1060};
1061
c5aa993b
JM
1062struct collection_list
1063 {
1064 unsigned char regs_mask[8]; /* room for up to 256 regs */
1065 long listsize;
1066 long next_memrange;
1067 struct memrange *list;
1068 long aexpr_listsize; /* size of array pointed to by expr_list elt */
1069 long next_aexpr_elt;
1070 struct agent_expr **aexpr_list;
1071
1072 }
1073tracepoint_list, stepping_list;
c906108c
SS
1074
1075/* MEMRANGE functions: */
1076
a14ed312 1077static int memrange_cmp (const void *, const void *);
c906108c
SS
1078
1079/* compare memranges for qsort */
1080static int
fba45db2 1081memrange_cmp (const void *va, const void *vb)
c906108c
SS
1082{
1083 const struct memrange *a = va, *b = vb;
1084
1085 if (a->type < b->type)
1086 return -1;
1087 if (a->type > b->type)
c5aa993b 1088 return 1;
c906108c
SS
1089 if (a->type == 0)
1090 {
c5aa993b
JM
1091 if ((bfd_vma) a->start < (bfd_vma) b->start)
1092 return -1;
1093 if ((bfd_vma) a->start > (bfd_vma) b->start)
1094 return 1;
c906108c
SS
1095 }
1096 else
1097 {
c5aa993b 1098 if (a->start < b->start)
c906108c 1099 return -1;
c5aa993b
JM
1100 if (a->start > b->start)
1101 return 1;
c906108c
SS
1102 }
1103 return 0;
1104}
1105
1106/* Sort the memrange list using qsort, and merge adjacent memranges */
1107static void
fba45db2 1108memrange_sortmerge (struct collection_list *memranges)
c906108c
SS
1109{
1110 int a, b;
1111
c5aa993b 1112 qsort (memranges->list, memranges->next_memrange,
c906108c
SS
1113 sizeof (struct memrange), memrange_cmp);
1114 if (memranges->next_memrange > 0)
1115 {
1116 for (a = 0, b = 1; b < memranges->next_memrange; b++)
1117 {
1118 if (memranges->list[a].type == memranges->list[b].type &&
c5aa993b 1119 memranges->list[b].start - memranges->list[a].end <=
c906108c
SS
1120 MAX_REGISTER_VIRTUAL_SIZE)
1121 {
1122 /* memrange b starts before memrange a ends; merge them. */
1123 if (memranges->list[b].end > memranges->list[a].end)
1124 memranges->list[a].end = memranges->list[b].end;
1125 continue; /* next b, same a */
1126 }
1127 a++; /* next a */
1128 if (a != b)
c5aa993b 1129 memcpy (&memranges->list[a], &memranges->list[b],
c906108c
SS
1130 sizeof (struct memrange));
1131 }
1132 memranges->next_memrange = a + 1;
1133 }
1134}
1135
1136/* Add a register to a collection list */
392a587b 1137static void
fba45db2 1138add_register (struct collection_list *collection, unsigned int regno)
c906108c
SS
1139{
1140 if (info_verbose)
1141 printf_filtered ("collect register %d\n", regno);
1142 if (regno > (8 * sizeof (collection->regs_mask)))
1143 error ("Internal: register number %d too large for tracepoint",
1144 regno);
c5aa993b 1145 collection->regs_mask[regno / 8] |= 1 << (regno % 8);
c906108c
SS
1146}
1147
1148/* Add a memrange to a collection list */
1149static void
fba45db2
KB
1150add_memrange (struct collection_list *memranges, int type, bfd_signed_vma base,
1151 unsigned long len)
c906108c
SS
1152{
1153 if (info_verbose)
104c1213
JM
1154 {
1155 printf_filtered ("(%d,", type);
1156 printf_vma (base);
1157 printf_filtered (",%ld)\n", len);
1158 }
1159
c906108c 1160 /* type: 0 == memory, n == basereg */
c5aa993b 1161 memranges->list[memranges->next_memrange].type = type;
c906108c
SS
1162 /* base: addr if memory, offset if reg relative. */
1163 memranges->list[memranges->next_memrange].start = base;
1164 /* len: we actually save end (base + len) for convenience */
c5aa993b 1165 memranges->list[memranges->next_memrange].end = base + len;
c906108c
SS
1166 memranges->next_memrange++;
1167 if (memranges->next_memrange >= memranges->listsize)
1168 {
1169 memranges->listsize *= 2;
c5aa993b 1170 memranges->list = xrealloc (memranges->list,
c906108c
SS
1171 memranges->listsize);
1172 }
1173
c5aa993b 1174 if (type != -1) /* better collect the base register! */
c906108c
SS
1175 add_register (memranges, type);
1176}
1177
1178/* Add a symbol to a collection list */
1179static void
fba45db2
KB
1180collect_symbol (struct collection_list *collect, struct symbol *sym,
1181 long frame_regno, long frame_offset)
c906108c 1182{
c5aa993b 1183 unsigned long len;
104c1213 1184 unsigned int reg;
c906108c
SS
1185 bfd_signed_vma offset;
1186
c5aa993b
JM
1187 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
1188 switch (SYMBOL_CLASS (sym))
1189 {
1190 default:
1191 printf_filtered ("%s: don't know symbol class %d\n",
1192 SYMBOL_NAME (sym), SYMBOL_CLASS (sym));
1193 break;
1194 case LOC_CONST:
104c1213 1195 printf_filtered ("constant %s (value %ld) will not be collected.\n",
c5aa993b
JM
1196 SYMBOL_NAME (sym), SYMBOL_VALUE (sym));
1197 break;
1198 case LOC_STATIC:
1199 offset = SYMBOL_VALUE_ADDRESS (sym);
1200 if (info_verbose)
104c1213
JM
1201 {
1202 char tmp[40];
1203
1204 sprintf_vma (tmp, offset);
1205 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1206 SYMBOL_NAME (sym), len, tmp /* address */);
1207 }
c5aa993b
JM
1208 add_memrange (collect, -1, offset, len); /* 0 == memory */
1209 break;
1210 case LOC_REGISTER:
1211 case LOC_REGPARM:
1212 reg = SYMBOL_VALUE (sym);
1213 if (info_verbose)
1214 printf_filtered ("LOC_REG[parm] %s: ", SYMBOL_NAME (sym));
1215 add_register (collect, reg);
1216 /* check for doubles stored in two registers */
1217 /* FIXME: how about larger types stored in 3 or more regs? */
1218 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
1219 len > REGISTER_RAW_SIZE (reg))
1220 add_register (collect, reg + 1);
1221 break;
1222 case LOC_REF_ARG:
1223 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1224 printf_filtered (" (will not collect %s)\n",
1225 SYMBOL_NAME (sym));
1226 break;
1227 case LOC_ARG:
1228 reg = frame_regno;
1229 offset = frame_offset + SYMBOL_VALUE (sym);
1230 if (info_verbose)
1231 {
104c1213 1232 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
c5aa993b 1233 SYMBOL_NAME (sym), len);
104c1213
JM
1234 printf_vma (offset);
1235 printf_filtered (" from frame ptr reg %d\n", reg);
c5aa993b
JM
1236 }
1237 add_memrange (collect, reg, offset, len);
1238 break;
1239 case LOC_REGPARM_ADDR:
1240 reg = SYMBOL_VALUE (sym);
1241 offset = 0;
1242 if (info_verbose)
1243 {
104c1213 1244 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
c5aa993b 1245 SYMBOL_NAME (sym), len);
104c1213
JM
1246 printf_vma (offset);
1247 printf_filtered (" from reg %d\n", reg);
c5aa993b
JM
1248 }
1249 add_memrange (collect, reg, offset, len);
1250 break;
1251 case LOC_LOCAL:
1252 case LOC_LOCAL_ARG:
1253 reg = frame_regno;
1254 offset = frame_offset + SYMBOL_VALUE (sym);
1255 if (info_verbose)
1256 {
104c1213 1257 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
c5aa993b 1258 SYMBOL_NAME (sym), len);
104c1213
JM
1259 printf_vma (offset);
1260 printf_filtered (" from frame ptr reg %d\n", reg);
c5aa993b
JM
1261 }
1262 add_memrange (collect, reg, offset, len);
1263 break;
1264 case LOC_BASEREG:
1265 case LOC_BASEREG_ARG:
1266 reg = SYMBOL_BASEREG (sym);
1267 offset = SYMBOL_VALUE (sym);
1268 if (info_verbose)
1269 {
104c1213
JM
1270 printf_filtered ("LOC_BASEREG %s: collect %ld bytes at offset ",
1271 SYMBOL_NAME (sym), len);
1272 printf_vma (offset);
1273 printf_filtered (" from basereg %d\n", reg);
c5aa993b
JM
1274 }
1275 add_memrange (collect, reg, offset, len);
1276 break;
1277 case LOC_UNRESOLVED:
1278 printf_filtered ("Don't know LOC_UNRESOLVED %s\n", SYMBOL_NAME (sym));
1279 break;
1280 case LOC_OPTIMIZED_OUT:
8e1a459b 1281 printf_filtered ("%s has been optimized out of existence.\n",
c5aa993b
JM
1282 SYMBOL_NAME (sym));
1283 break;
1284 }
c906108c
SS
1285}
1286
1287/* Add all locals (or args) symbols to collection list */
1288static void
fba45db2
KB
1289add_local_symbols (struct collection_list *collect, CORE_ADDR pc,
1290 long frame_regno, long frame_offset, int type)
c906108c
SS
1291{
1292 struct symbol *sym;
c5aa993b 1293 struct block *block;
c906108c
SS
1294 int i, nsyms, count = 0;
1295
1296 block = block_for_pc (pc);
1297 while (block != 0)
1298 {
c5aa993b 1299 QUIT; /* allow user to bail out with ^C */
c906108c
SS
1300 nsyms = BLOCK_NSYMS (block);
1301 for (i = 0; i < nsyms; i++)
1302 {
1303 sym = BLOCK_SYM (block, i);
c5aa993b
JM
1304 switch (SYMBOL_CLASS (sym))
1305 {
104c1213
JM
1306 default:
1307 warning ("don't know how to trace local symbol %s",
1308 SYMBOL_NAME (sym));
c5aa993b
JM
1309 case LOC_LOCAL:
1310 case LOC_STATIC:
1311 case LOC_REGISTER:
1312 case LOC_BASEREG:
1313 if (type == 'L') /* collecting Locals */
1314 {
1315 count++;
1316 collect_symbol (collect, sym, frame_regno, frame_offset);
1317 }
1318 break;
1319 case LOC_ARG:
1320 case LOC_LOCAL_ARG:
1321 case LOC_REF_ARG:
1322 case LOC_REGPARM:
1323 case LOC_REGPARM_ADDR:
1324 case LOC_BASEREG_ARG:
1325 if (type == 'A') /* collecting Arguments */
1326 {
1327 count++;
1328 collect_symbol (collect, sym, frame_regno, frame_offset);
1329 }
1330 }
c906108c
SS
1331 }
1332 if (BLOCK_FUNCTION (block))
1333 break;
1334 else
1335 block = BLOCK_SUPERBLOCK (block);
1336 }
1337 if (count == 0)
1338 warning ("No %s found in scope.", type == 'L' ? "locals" : "args");
1339}
1340
1341/* worker function */
1342static void
fba45db2 1343clear_collection_list (struct collection_list *list)
c906108c
SS
1344{
1345 int ndx;
1346
1347 list->next_memrange = 0;
1348 for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1349 {
c5aa993b 1350 free_agent_expr (list->aexpr_list[ndx]);
c906108c
SS
1351 list->aexpr_list[ndx] = NULL;
1352 }
1353 list->next_aexpr_elt = 0;
1354 memset (list->regs_mask, 0, sizeof (list->regs_mask));
1355}
1356
1357/* reduce a collection list to string form (for gdb protocol) */
1358static char **
fba45db2 1359stringify_collection_list (struct collection_list *list, char *string)
c906108c
SS
1360{
1361 char temp_buf[2048];
104c1213 1362 char tmp2[40];
c906108c
SS
1363 int count;
1364 int ndx = 0;
1365 char *(*str_list)[];
1366 char *end;
c5aa993b 1367 long i;
c906108c
SS
1368
1369 count = 1 + list->next_memrange + list->next_aexpr_elt + 1;
c5aa993b 1370 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
c906108c
SS
1371
1372 for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1373 if (list->regs_mask[i] != 0) /* skip leading zeroes in regs_mask */
1374 break;
1375 if (list->regs_mask[i] != 0) /* prepare to send regs_mask to the stub */
1376 {
1377 if (info_verbose)
1378 printf_filtered ("\nCollecting registers (mask): 0x");
1379 end = temp_buf;
c5aa993b 1380 *end++ = 'R';
c906108c
SS
1381 for (; i >= 0; i--)
1382 {
c5aa993b 1383 QUIT; /* allow user to bail out with ^C */
c906108c
SS
1384 if (info_verbose)
1385 printf_filtered ("%02X", list->regs_mask[i]);
c5aa993b 1386 sprintf (end, "%02X", list->regs_mask[i]);
c906108c
SS
1387 end += 2;
1388 }
c5aa993b 1389 (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
c906108c
SS
1390 ndx++;
1391 }
1392 if (info_verbose)
1393 printf_filtered ("\n");
1394 if (list->next_memrange > 0 && info_verbose)
1395 printf_filtered ("Collecting memranges: \n");
1396 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1397 {
1398 QUIT; /* allow user to bail out with ^C */
104c1213 1399 sprintf_vma (tmp2, list->list[i].start);
c906108c 1400 if (info_verbose)
104c1213
JM
1401 {
1402 printf_filtered ("(%d, %s, %ld)\n",
1403 list->list[i].type,
1404 tmp2,
1405 (long) (list->list[i].end - list->list[i].start));
1406 }
c906108c
SS
1407 if (count + 27 > MAX_AGENT_EXPR_LEN)
1408 {
c5aa993b 1409 (*str_list)[ndx] = savestring (temp_buf, count);
c906108c
SS
1410 ndx++;
1411 count = 0;
1412 end = temp_buf;
1413 }
104c1213
JM
1414
1415 sprintf (end, "M%X,%s,%lX",
c5aa993b 1416 list->list[i].type,
104c1213
JM
1417 tmp2,
1418 (long) (list->list[i].end - list->list[i].start));
1419
c906108c 1420 count += strlen (end);
104c1213 1421 end += count;
c906108c
SS
1422 }
1423
1424 for (i = 0; i < list->next_aexpr_elt; i++)
1425 {
1426 QUIT; /* allow user to bail out with ^C */
1427 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1428 {
c5aa993b 1429 (*str_list)[ndx] = savestring (temp_buf, count);
c906108c
SS
1430 ndx++;
1431 count = 0;
1432 end = temp_buf;
1433 }
1434 sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1435 end += 10; /* 'X' + 8 hex digits + ',' */
1436 count += 10;
1437
c5aa993b 1438 end = mem2hex (list->aexpr_list[i]->buf, end, list->aexpr_list[i]->len);
c906108c
SS
1439 count += 2 * list->aexpr_list[i]->len;
1440 }
1441
1442 if (count != 0)
1443 {
c5aa993b 1444 (*str_list)[ndx] = savestring (temp_buf, count);
c906108c
SS
1445 ndx++;
1446 count = 0;
1447 end = temp_buf;
1448 }
1449 (*str_list)[ndx] = NULL;
1450
1451 if (ndx == 0)
1452 return NULL;
1453 else
1454 return *str_list;
1455}
1456
392a587b 1457static void
fba45db2 1458free_actions_list_cleanup_wrapper (void *al)
392a587b
JM
1459{
1460 free_actions_list (al);
1461}
1462
1463static void
fba45db2 1464free_actions_list (char **actions_list)
c906108c
SS
1465{
1466 int ndx;
1467
1468 if (actions_list == 0)
1469 return;
1470
1471 for (ndx = 0; actions_list[ndx]; ndx++)
b8c9b27d 1472 xfree (actions_list[ndx]);
c906108c 1473
b8c9b27d 1474 xfree (actions_list);
c906108c
SS
1475}
1476
1477/* render all actions into gdb protocol */
1478static void
fba45db2
KB
1479encode_actions (struct tracepoint *t, char ***tdp_actions,
1480 char ***stepping_actions)
c906108c 1481{
c5aa993b
JM
1482 static char tdp_buff[2048], step_buff[2048];
1483 char *action_exp;
1484 struct expression *exp = NULL;
c906108c 1485 struct action_line *action;
104c1213 1486 int i;
c5aa993b
JM
1487 value_ptr tempval;
1488 struct collection_list *collect;
c906108c
SS
1489 struct cmd_list_element *cmd;
1490 struct agent_expr *aexpr;
39d4ef09
AC
1491 int frame_reg;
1492 LONGEST frame_offset;
c906108c
SS
1493
1494
1495 clear_collection_list (&tracepoint_list);
1496 clear_collection_list (&stepping_list);
1497 collect = &tracepoint_list;
1498
1499 *tdp_actions = NULL;
1500 *stepping_actions = NULL;
1501
1502 TARGET_VIRTUAL_FRAME_POINTER (t->address, &frame_reg, &frame_offset);
1503
1504 for (action = t->actions; action; action = action->next)
1505 {
1506 QUIT; /* allow user to bail out with ^C */
1507 action_exp = action->action;
104c1213 1508 while (isspace ((int) *action_exp))
c906108c
SS
1509 action_exp++;
1510
1511 if (*action_exp == '#') /* comment line */
1512 return;
1513
1514 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1515 if (cmd == 0)
1516 error ("Bad action list item: %s", action_exp);
1517
1518 if (cmd->function.cfunc == collect_pseudocommand)
1519 {
c5aa993b
JM
1520 do
1521 { /* repeat over a comma-separated list */
1522 QUIT; /* allow user to bail out with ^C */
104c1213 1523 while (isspace ((int) *action_exp))
c5aa993b 1524 action_exp++;
c906108c 1525
c5aa993b
JM
1526 if (0 == strncasecmp ("$reg", action_exp, 4))
1527 {
1528 for (i = 0; i < NUM_REGS; i++)
1529 add_register (collect, i);
1530 action_exp = strchr (action_exp, ','); /* more? */
1531 }
1532 else if (0 == strncasecmp ("$arg", action_exp, 4))
1533 {
1534 add_local_symbols (collect,
1535 t->address,
1536 frame_reg,
1537 frame_offset,
1538 'A');
1539 action_exp = strchr (action_exp, ','); /* more? */
1540 }
1541 else if (0 == strncasecmp ("$loc", action_exp, 4))
1542 {
1543 add_local_symbols (collect,
1544 t->address,
1545 frame_reg,
1546 frame_offset,
1547 'L');
1548 action_exp = strchr (action_exp, ','); /* more? */
1549 }
1550 else
1551 {
1552 unsigned long addr, len;
1553 struct cleanup *old_chain = NULL;
1554 struct cleanup *old_chain1 = NULL;
1555 struct agent_reqs areqs;
1556
75ac9d7b
MS
1557 exp = parse_exp_1 (&action_exp,
1558 block_for_pc (t->address), 1);
74b7792f 1559 old_chain = make_cleanup (free_current_contents, &exp);
c906108c 1560
c5aa993b
JM
1561 switch (exp->elts[0].opcode)
1562 {
1563 case OP_REGISTER:
1564 i = exp->elts[1].longconst;
1565 if (info_verbose)
1566 printf_filtered ("OP_REGISTER: ");
1567 add_register (collect, i);
1568 break;
1569
1570 case UNOP_MEMVAL:
1571 /* safe because we know it's a simple expression */
1572 tempval = evaluate_expression (exp);
1573 addr = VALUE_ADDRESS (tempval) + VALUE_OFFSET (tempval);
1574 len = TYPE_LENGTH (check_typedef (exp->elts[1].type));
1575 add_memrange (collect, -1, addr, len);
1576 break;
1577
1578 case OP_VAR_VALUE:
1579 collect_symbol (collect,
1580 exp->elts[2].symbol,
1581 frame_reg,
1582 frame_offset);
1583 break;
1584
1585 default: /* full-fledged expression */
1586 aexpr = gen_trace_for_expr (t->address, exp);
1587
f23d52e0 1588 old_chain1 = make_cleanup_free_agent_expr (aexpr);
c5aa993b
JM
1589
1590 ax_reqs (aexpr, &areqs);
1591 if (areqs.flaw != agent_flaw_none)
1592 error ("malformed expression");
1593
1594 if (areqs.min_height < 0)
1595 error ("gdb: Internal error: expression has min height < 0");
1596 if (areqs.max_height > 20)
1597 error ("expression too complicated, try simplifying");
1598
1599 discard_cleanups (old_chain1);
1600 add_aexpr (collect, aexpr);
1601
1602 /* take care of the registers */
1603 if (areqs.reg_mask_len > 0)
c906108c 1604 {
c5aa993b
JM
1605 int ndx1;
1606 int ndx2;
1607
1608 for (ndx1 = 0; ndx1 < areqs.reg_mask_len; ndx1++)
c906108c 1609 {
c5aa993b
JM
1610 QUIT; /* allow user to bail out with ^C */
1611 if (areqs.reg_mask[ndx1] != 0)
1612 {
1613 /* assume chars have 8 bits */
1614 for (ndx2 = 0; ndx2 < 8; ndx2++)
1615 if (areqs.reg_mask[ndx1] & (1 << ndx2))
1616 /* it's used -- record it */
1617 add_register (collect, ndx1 * 8 + ndx2);
1618 }
c906108c
SS
1619 }
1620 }
c5aa993b
JM
1621 break;
1622 } /* switch */
1623 do_cleanups (old_chain);
1624 } /* do */
1625 }
1626 while (action_exp && *action_exp++ == ',');
1627 } /* if */
c906108c
SS
1628 else if (cmd->function.cfunc == while_stepping_pseudocommand)
1629 {
1630 collect = &stepping_list;
1631 }
1632 else if (cmd->function.cfunc == end_actions_pseudocommand)
1633 {
1634 if (collect == &stepping_list) /* end stepping actions */
1635 collect = &tracepoint_list;
1636 else
c5aa993b 1637 break; /* end tracepoint actions */
c906108c 1638 }
c5aa993b
JM
1639 } /* for */
1640 memrange_sortmerge (&tracepoint_list);
1641 memrange_sortmerge (&stepping_list);
c906108c 1642
710b33bd
AC
1643 *tdp_actions = stringify_collection_list (&tracepoint_list, tdp_buff);
1644 *stepping_actions = stringify_collection_list (&stepping_list, step_buff);
c906108c
SS
1645}
1646
1647static void
fba45db2 1648add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
c906108c
SS
1649{
1650 if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1651 {
1652 collect->aexpr_list =
1653 xrealloc (collect->aexpr_list,
c5aa993b 1654 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
c906108c
SS
1655 collect->aexpr_listsize *= 2;
1656 }
1657 collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1658 collect->next_aexpr_elt++;
1659}
1660
1661static char target_buf[2048];
1662
1663/* Set "transparent" memory ranges
1664
1665 Allow trace mechanism to treat text-like sections
1666 (and perhaps all read-only sections) transparently,
1667 i.e. don't reject memory requests from these address ranges
1668 just because they haven't been collected. */
1669
1670static void
1671remote_set_transparent_ranges (void)
1672{
1673 extern bfd *exec_bfd;
1674 asection *s;
1675 bfd_size_type size;
1676 bfd_vma lma;
1677 int anysecs = 0;
1678
1679 if (!exec_bfd)
c5aa993b 1680 return; /* no information to give. */
c906108c
SS
1681
1682 strcpy (target_buf, "QTro");
1683 for (s = exec_bfd->sections; s; s = s->next)
1684 {
104c1213 1685 char tmp1[40], tmp2[40];
c906108c 1686
c5aa993b
JM
1687 if ((s->flags & SEC_LOAD) == 0 ||
1688 /* (s->flags & SEC_CODE) == 0 || */
c906108c
SS
1689 (s->flags & SEC_READONLY) == 0)
1690 continue;
1691
1692 anysecs = 1;
c5aa993b 1693 lma = s->lma;
c906108c 1694 size = bfd_get_section_size_before_reloc (s);
104c1213
JM
1695 sprintf_vma (tmp1, lma);
1696 sprintf_vma (tmp2, lma + size);
1697 sprintf (target_buf + strlen (target_buf),
1698 ":%s,%s", tmp1, tmp2);
c906108c
SS
1699 }
1700 if (anysecs)
1701 {
1702 putpkt (target_buf);
c2d11a7d 1703 getpkt (target_buf, sizeof (target_buf), 0);
c906108c
SS
1704 }
1705}
1706
1707/* tstart command:
c5aa993b 1708
c906108c
SS
1709 Tell target to clear any previous trace experiment.
1710 Walk the list of tracepoints, and send them (and their actions)
1711 to the target. If no errors,
1712 Tell target to start a new trace experiment. */
1713
1714static void
fba45db2 1715trace_start_command (char *args, int from_tty)
c5aa993b 1716{ /* STUB_COMM MOSTLY_IMPLEMENTED */
c906108c
SS
1717 struct tracepoint *t;
1718 char buf[2048];
1719 char **tdp_actions;
1720 char **stepping_actions;
1721 int ndx;
1722 struct cleanup *old_chain = NULL;
1723
c5aa993b
JM
1724 dont_repeat (); /* like "run", dangerous to repeat accidentally */
1725
c906108c
SS
1726 if (target_is_remote ())
1727 {
1728 putpkt ("QTinit");
c2d11a7d 1729 remote_get_noisy_reply (target_buf, sizeof (target_buf));
c906108c
SS
1730 if (strcmp (target_buf, "OK"))
1731 error ("Target does not support this command.");
1732
1733 ALL_TRACEPOINTS (t)
c5aa993b 1734 {
104c1213 1735 char tmp[40];
c906108c 1736
104c1213 1737 sprintf_vma (tmp, t->address);
c4093a6a 1738 sprintf (buf, "QTDP:%x:%s:%c:%lx:%x", t->number, tmp, /* address */
b5de0fa7 1739 t->enabled_p ? 'E' : 'D',
c5aa993b
JM
1740 t->step_count, t->pass_count);
1741
1742 if (t->actions)
1743 strcat (buf, "-");
1744 putpkt (buf);
c2d11a7d 1745 remote_get_noisy_reply (target_buf, sizeof (target_buf));
c5aa993b
JM
1746 if (strcmp (target_buf, "OK"))
1747 error ("Target does not support tracepoints.");
1748
1749 if (t->actions)
1750 {
1751 encode_actions (t, &tdp_actions, &stepping_actions);
1752 old_chain = make_cleanup (free_actions_list_cleanup_wrapper,
1753 tdp_actions);
1754 (void) make_cleanup (free_actions_list_cleanup_wrapper,
1755 stepping_actions);
1756
1757 /* do_single_steps (t); */
1758 if (tdp_actions)
1759 {
1760 for (ndx = 0; tdp_actions[ndx]; ndx++)
1761 {
1762 QUIT; /* allow user to bail out with ^C */
104c1213
JM
1763 sprintf (buf, "QTDP:-%x:%s:%s%c",
1764 t->number, tmp, /* address */
c5aa993b
JM
1765 tdp_actions[ndx],
1766 ((tdp_actions[ndx + 1] || stepping_actions)
1767 ? '-' : 0));
1768 putpkt (buf);
c2d11a7d 1769 remote_get_noisy_reply (target_buf, sizeof (target_buf));
c5aa993b
JM
1770 if (strcmp (target_buf, "OK"))
1771 error ("Error on target while setting tracepoints.");
1772 }
1773 }
1774 if (stepping_actions)
1775 {
1776 for (ndx = 0; stepping_actions[ndx]; ndx++)
1777 {
1778 QUIT; /* allow user to bail out with ^C */
104c1213
JM
1779 sprintf (buf, "QTDP:-%x:%s:%s%s%s",
1780 t->number, tmp, /* address */
c5aa993b
JM
1781 ((ndx == 0) ? "S" : ""),
1782 stepping_actions[ndx],
1783 (stepping_actions[ndx + 1] ? "-" : ""));
1784 putpkt (buf);
c2d11a7d 1785 remote_get_noisy_reply (target_buf, sizeof (target_buf));
c5aa993b
JM
1786 if (strcmp (target_buf, "OK"))
1787 error ("Error on target while setting tracepoints.");
1788 }
1789 }
1790
1791 do_cleanups (old_chain);
1792 }
1793 }
c906108c
SS
1794 /* Tell target to treat text-like sections as transparent */
1795 remote_set_transparent_ranges ();
1796 /* Now insert traps and begin collecting data */
1797 putpkt ("QTStart");
c2d11a7d 1798 remote_get_noisy_reply (target_buf, sizeof (target_buf));
c906108c
SS
1799 if (strcmp (target_buf, "OK"))
1800 error ("Bogus reply from target: %s", target_buf);
1801 set_traceframe_num (-1); /* all old traceframes invalidated */
1802 set_tracepoint_num (-1);
c5aa993b 1803 set_traceframe_context (-1);
c906108c
SS
1804 trace_running_p = 1;
1805 if (trace_start_stop_hook)
c5aa993b
JM
1806 trace_start_stop_hook (1, from_tty);
1807
c906108c
SS
1808 }
1809 else
1810 error ("Trace can only be run on remote targets.");
1811}
1812
1813/* tstop command */
1814static void
fba45db2 1815trace_stop_command (char *args, int from_tty)
c5aa993b 1816{ /* STUB_COMM IS_IMPLEMENTED */
c906108c
SS
1817 if (target_is_remote ())
1818 {
1819 putpkt ("QTStop");
c2d11a7d 1820 remote_get_noisy_reply (target_buf, sizeof (target_buf));
c906108c
SS
1821 if (strcmp (target_buf, "OK"))
1822 error ("Bogus reply from target: %s", target_buf);
1823 trace_running_p = 0;
1824 if (trace_start_stop_hook)
c5aa993b 1825 trace_start_stop_hook (0, from_tty);
c906108c
SS
1826 }
1827 else
1828 error ("Trace can only be run on remote targets.");
1829}
1830
1831unsigned long trace_running_p;
1832
1833/* tstatus command */
1834static void
fba45db2 1835trace_status_command (char *args, int from_tty)
c5aa993b 1836{ /* STUB_COMM IS_IMPLEMENTED */
c906108c
SS
1837 if (target_is_remote ())
1838 {
1839 putpkt ("qTStatus");
c2d11a7d 1840 remote_get_noisy_reply (target_buf, sizeof (target_buf));
c906108c
SS
1841
1842 if (target_buf[0] != 'T' ||
1843 (target_buf[1] != '0' && target_buf[1] != '1'))
1844 error ("Bogus reply from target: %s", target_buf);
1845
1846 /* exported for use by the GUI */
1847 trace_running_p = (target_buf[1] == '1');
1848 }
1849 else
1850 error ("Trace can only be run on remote targets.");
1851}
1852
1853/* Worker function for the various flavors of the tfind command */
1854static void
c2d11a7d
JM
1855finish_tfind_command (char *msg,
1856 long sizeof_msg,
1857 int from_tty)
c906108c
SS
1858{
1859 int target_frameno = -1, target_tracept = -1;
1860 CORE_ADDR old_frame_addr;
1861 struct symbol *old_func;
1862 char *reply;
1863
1864 old_frame_addr = FRAME_FP (get_current_frame ());
c5aa993b 1865 old_func = find_pc_function (read_pc ());
c906108c
SS
1866
1867 putpkt (msg);
c2d11a7d 1868 reply = remote_get_noisy_reply (msg, sizeof_msg);
c906108c
SS
1869
1870 while (reply && *reply)
c5aa993b
JM
1871 switch (*reply)
1872 {
1873 case 'F':
1874 if ((target_frameno = (int) strtol (++reply, &reply, 16)) == -1)
1875 {
1876 /* A request for a non-existant trace frame has failed.
1877 Our response will be different, depending on FROM_TTY:
1878
1879 If FROM_TTY is true, meaning that this command was
1880 typed interactively by the user, then give an error
1881 and DO NOT change the state of traceframe_number etc.
1882
1883 However if FROM_TTY is false, meaning that we're either
1884 in a script, a loop, or a user-defined command, then
1885 DON'T give an error, but DO change the state of
1886 traceframe_number etc. to invalid.
1887
1888 The rationalle is that if you typed the command, you
1889 might just have committed a typo or something, and you'd
1890 like to NOT lose your current debugging state. However
1891 if you're in a user-defined command or especially in a
1892 loop, then you need a way to detect that the command
1893 failed WITHOUT aborting. This allows you to write
1894 scripts that search thru the trace buffer until the end,
1895 and then continue on to do something else. */
1896
1897 if (from_tty)
1898 error ("Target failed to find requested trace frame.");
1899 else
1900 {
1901 if (info_verbose)
1902 printf_filtered ("End of trace buffer.\n");
1903 /* The following will not recurse, since it's special-cased */
1904 trace_find_command ("-1", from_tty);
1905 reply = NULL; /* break out of loop,
c906108c 1906 (avoid recursive nonsense) */
c5aa993b
JM
1907 }
1908 }
1909 break;
1910 case 'T':
1911 if ((target_tracept = (int) strtol (++reply, &reply, 16)) == -1)
1912 error ("Target failed to find requested trace frame.");
1913 break;
1914 case 'O': /* "OK"? */
1915 if (reply[1] == 'K' && reply[2] == '\0')
1916 reply += 2;
1917 else
1918 error ("Bogus reply from target: %s", reply);
1919 break;
1920 default:
c906108c 1921 error ("Bogus reply from target: %s", reply);
c5aa993b 1922 }
c906108c
SS
1923
1924 flush_cached_frames ();
1925 registers_changed ();
1926 select_frame (get_current_frame (), 0);
1927 set_traceframe_num (target_frameno);
1928 set_tracepoint_num (target_tracept);
1929 if (target_frameno == -1)
1930 set_traceframe_context (-1);
1931 else
1932 set_traceframe_context (read_pc ());
1933
1934 if (from_tty)
1935 {
1936 int source_only;
1937
1938 /* NOTE: in immitation of the step command, try to determine
c5aa993b
JM
1939 whether we have made a transition from one function to another.
1940 If so, we'll print the "stack frame" (ie. the new function and
1941 it's arguments) -- otherwise we'll just show the new source line.
1942
1943 This determination is made by checking (1) whether the current
1944 function has changed, and (2) whether the current FP has changed.
1945 Hack: if the FP wasn't collected, either at the current or the
1946 previous frame, assume that the FP has NOT changed. */
1947
1948 if (old_func == find_pc_function (read_pc ()) &&
1949 (old_frame_addr == 0 ||
1950 FRAME_FP (get_current_frame ()) == 0 ||
1951 old_frame_addr == FRAME_FP (get_current_frame ())))
c906108c
SS
1952 source_only = -1;
1953 else
c5aa993b 1954 source_only = 1;
c906108c
SS
1955
1956 print_stack_frame (selected_frame, selected_frame_level, source_only);
1957 do_displays ();
1958 }
1959}
1960
1961/* trace_find_command takes a trace frame number n,
1962 sends "QTFrame:<n>" to the target,
1963 and accepts a reply that may contain several optional pieces
1964 of information: a frame number, a tracepoint number, and an
1965 indication of whether this is a trap frame or a stepping frame.
1966
1967 The minimal response is just "OK" (which indicates that the
1968 target does not give us a frame number or a tracepoint number).
1969 Instead of that, the target may send us a string containing
1970 any combination of:
c5aa993b
JM
1971 F<hexnum> (gives the selected frame number)
1972 T<hexnum> (gives the selected tracepoint number)
1973 */
c906108c
SS
1974
1975/* tfind command */
1976static void
fba45db2 1977trace_find_command (char *args, int from_tty)
c5aa993b 1978{ /* STUB_COMM PART_IMPLEMENTED */
c906108c
SS
1979 /* this should only be called with a numeric argument */
1980 int frameno = -1;
c906108c
SS
1981
1982 if (target_is_remote ())
1983 {
1984 if (trace_find_hook)
c5aa993b
JM
1985 trace_find_hook (args, from_tty);
1986
c906108c 1987 if (args == 0 || *args == 0)
c5aa993b 1988 { /* TFIND with no args means find NEXT trace frame. */
c906108c
SS
1989 if (traceframe_number == -1)
1990 frameno = 0; /* "next" is first one */
1991 else
1992 frameno = traceframe_number + 1;
1993 }
1994 else if (0 == strcmp (args, "-"))
1995 {
1996 if (traceframe_number == -1)
1997 error ("not debugging trace buffer");
1998 else if (from_tty && traceframe_number == 0)
1999 error ("already at start of trace buffer");
2000
2001 frameno = traceframe_number - 1;
2002 }
2003 else
bb518678 2004 frameno = parse_and_eval_long (args);
c906108c
SS
2005
2006 if (frameno < -1)
2007 error ("invalid input (%d is less than zero)", frameno);
2008
2009 sprintf (target_buf, "QTFrame:%x", frameno);
c2d11a7d 2010 finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
c906108c
SS
2011 }
2012 else
2013 error ("Trace can only be run on remote targets.");
2014}
2015
2016/* tfind end */
2017static void
fba45db2 2018trace_find_end_command (char *args, int from_tty)
c906108c
SS
2019{
2020 trace_find_command ("-1", from_tty);
2021}
2022
2023/* tfind none */
2024static void
fba45db2 2025trace_find_none_command (char *args, int from_tty)
c906108c
SS
2026{
2027 trace_find_command ("-1", from_tty);
2028}
2029
2030/* tfind start */
2031static void
fba45db2 2032trace_find_start_command (char *args, int from_tty)
c906108c
SS
2033{
2034 trace_find_command ("0", from_tty);
2035}
2036
2037/* tfind pc command */
2038static void
fba45db2 2039trace_find_pc_command (char *args, int from_tty)
c5aa993b 2040{ /* STUB_COMM PART_IMPLEMENTED */
c906108c 2041 CORE_ADDR pc;
104c1213 2042 char tmp[40];
c906108c
SS
2043
2044 if (target_is_remote ())
2045 {
2046 if (args == 0 || *args == 0)
2047 pc = read_pc (); /* default is current pc */
2048 else
2049 pc = parse_and_eval_address (args);
2050
104c1213
JM
2051 sprintf_vma (tmp, pc);
2052 sprintf (target_buf, "QTFrame:pc:%s", tmp);
c2d11a7d 2053 finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
c906108c
SS
2054 }
2055 else
2056 error ("Trace can only be run on remote targets.");
2057}
2058
2059/* tfind tracepoint command */
2060static void
fba45db2 2061trace_find_tracepoint_command (char *args, int from_tty)
c5aa993b 2062{ /* STUB_COMM PART_IMPLEMENTED */
c906108c 2063 int tdp;
c906108c
SS
2064
2065 if (target_is_remote ())
2066 {
2067 if (args == 0 || *args == 0)
2068 if (tracepoint_number == -1)
2069 error ("No current tracepoint -- please supply an argument.");
2070 else
2071 tdp = tracepoint_number; /* default is current TDP */
2072 else
0e828ed1 2073 tdp = parse_and_eval_long (args);
c906108c
SS
2074
2075 sprintf (target_buf, "QTFrame:tdp:%x", tdp);
c2d11a7d 2076 finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
c906108c
SS
2077 }
2078 else
2079 error ("Trace can only be run on remote targets.");
2080}
2081
2082/* TFIND LINE command:
c5aa993b 2083
c906108c
SS
2084 This command will take a sourceline for argument, just like BREAK
2085 or TRACE (ie. anything that "decode_line_1" can handle).
c5aa993b 2086
c906108c
SS
2087 With no argument, this command will find the next trace frame
2088 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2089
2090static void
fba45db2 2091trace_find_line_command (char *args, int from_tty)
c5aa993b 2092{ /* STUB_COMM PART_IMPLEMENTED */
c906108c
SS
2093 static CORE_ADDR start_pc, end_pc;
2094 struct symtabs_and_lines sals;
2095 struct symtab_and_line sal;
c906108c 2096 struct cleanup *old_chain;
104c1213 2097 char startpc_str[40], endpc_str[40];
c906108c
SS
2098
2099 if (target_is_remote ())
2100 {
2101 if (args == 0 || *args == 0)
2102 {
2103 sal = find_pc_line ((get_current_frame ())->pc, 0);
2104 sals.nelts = 1;
2105 sals.sals = (struct symtab_and_line *)
2106 xmalloc (sizeof (struct symtab_and_line));
2107 sals.sals[0] = sal;
2108 }
2109 else
2110 {
2111 sals = decode_line_spec (args, 1);
c5aa993b 2112 sal = sals.sals[0];
c906108c
SS
2113 }
2114
b8c9b27d 2115 old_chain = make_cleanup (xfree, sals.sals);
c906108c
SS
2116 if (sal.symtab == 0)
2117 {
2118 printf_filtered ("TFIND: No line number information available");
2119 if (sal.pc != 0)
2120 {
2121 /* This is useful for "info line *0x7f34". If we can't tell the
c5aa993b
JM
2122 user about a source line, at least let them have the symbolic
2123 address. */
c906108c
SS
2124 printf_filtered (" for address ");
2125 wrap_here (" ");
2126 print_address (sal.pc, gdb_stdout);
2127 printf_filtered (";\n -- will attempt to find by PC. \n");
2128 }
2129 else
2130 {
2131 printf_filtered (".\n");
c5aa993b 2132 return; /* no line, no PC; what can we do? */
c906108c
SS
2133 }
2134 }
2135 else if (sal.line > 0
2136 && find_line_pc_range (sal, &start_pc, &end_pc))
2137 {
2138 if (start_pc == end_pc)
2139 {
2140 printf_filtered ("Line %d of \"%s\"",
2141 sal.line, sal.symtab->filename);
2142 wrap_here (" ");
2143 printf_filtered (" is at address ");
2144 print_address (start_pc, gdb_stdout);
2145 wrap_here (" ");
2146 printf_filtered (" but contains no code.\n");
2147 sal = find_pc_line (start_pc, 0);
2148 if (sal.line > 0 &&
2149 find_line_pc_range (sal, &start_pc, &end_pc) &&
2150 start_pc != end_pc)
2151 printf_filtered ("Attempting to find line %d instead.\n",
2152 sal.line);
2153 else
2154 error ("Cannot find a good line.");
2155 }
2156 }
2157 else
2158 /* Is there any case in which we get here, and have an address
2159 which the user would want to see? If we have debugging symbols
2160 and no line numbers? */
2161 error ("Line number %d is out of range for \"%s\".\n",
2162 sal.line, sal.symtab->filename);
2163
104c1213
JM
2164 sprintf_vma (startpc_str, start_pc);
2165 sprintf_vma (endpc_str, end_pc - 1);
c906108c 2166 if (args && *args) /* find within range of stated line */
104c1213 2167 sprintf (target_buf, "QTFrame:range:%s:%s", startpc_str, endpc_str);
c906108c 2168 else /* find OUTSIDE OF range of CURRENT line */
104c1213 2169 sprintf (target_buf, "QTFrame:outside:%s:%s", startpc_str, endpc_str);
c2d11a7d 2170 finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
c906108c
SS
2171 do_cleanups (old_chain);
2172 }
2173 else
c5aa993b 2174 error ("Trace can only be run on remote targets.");
c906108c
SS
2175}
2176
2177/* tfind range command */
2178static void
fba45db2 2179trace_find_range_command (char *args, int from_tty)
104c1213 2180{
c906108c 2181 static CORE_ADDR start, stop;
104c1213 2182 char start_str[40], stop_str[40];
c906108c
SS
2183 char *tmp;
2184
2185 if (target_is_remote ())
2186 {
2187 if (args == 0 || *args == 0)
104c1213 2188 { /* XXX FIXME: what should default behavior be? */
c906108c
SS
2189 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2190 return;
2191 }
2192
c5aa993b 2193 if (0 != (tmp = strchr (args, ',')))
c906108c
SS
2194 {
2195 *tmp++ = '\0'; /* terminate start address */
104c1213 2196 while (isspace ((int) *tmp))
c906108c
SS
2197 tmp++;
2198 start = parse_and_eval_address (args);
c5aa993b 2199 stop = parse_and_eval_address (tmp);
c906108c
SS
2200 }
2201 else
c5aa993b 2202 { /* no explicit end address? */
c906108c 2203 start = parse_and_eval_address (args);
c5aa993b 2204 stop = start + 1; /* ??? */
c906108c
SS
2205 }
2206
104c1213
JM
2207 sprintf_vma (start_str, start);
2208 sprintf_vma (stop_str, stop);
2209 sprintf (target_buf, "QTFrame:range:%s:%s", start_str, stop_str);
c2d11a7d 2210 finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
c906108c
SS
2211 }
2212 else
c5aa993b 2213 error ("Trace can only be run on remote targets.");
c906108c
SS
2214}
2215
2216/* tfind outside command */
2217static void
fba45db2 2218trace_find_outside_command (char *args, int from_tty)
104c1213 2219{
c906108c 2220 CORE_ADDR start, stop;
104c1213 2221 char start_str[40], stop_str[40];
c906108c
SS
2222 char *tmp;
2223
2224 if (target_is_remote ())
2225 {
2226 if (args == 0 || *args == 0)
104c1213 2227 { /* XXX FIXME: what should default behavior be? */
c906108c
SS
2228 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2229 return;
2230 }
2231
c5aa993b 2232 if (0 != (tmp = strchr (args, ',')))
c906108c
SS
2233 {
2234 *tmp++ = '\0'; /* terminate start address */
104c1213 2235 while (isspace ((int) *tmp))
c906108c
SS
2236 tmp++;
2237 start = parse_and_eval_address (args);
c5aa993b 2238 stop = parse_and_eval_address (tmp);
c906108c
SS
2239 }
2240 else
c5aa993b 2241 { /* no explicit end address? */
c906108c 2242 start = parse_and_eval_address (args);
c5aa993b 2243 stop = start + 1; /* ??? */
c906108c
SS
2244 }
2245
104c1213
JM
2246 sprintf_vma (start_str, start);
2247 sprintf_vma (stop_str, stop);
2248 sprintf (target_buf, "QTFrame:outside:%s:%s", start_str, stop_str);
c2d11a7d 2249 finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
c906108c
SS
2250 }
2251 else
c5aa993b 2252 error ("Trace can only be run on remote targets.");
c906108c
SS
2253}
2254
2255/* save-tracepoints command */
2256static void
fba45db2 2257tracepoint_save_command (char *args, int from_tty)
c906108c 2258{
c5aa993b 2259 struct tracepoint *tp;
c906108c
SS
2260 struct action_line *line;
2261 FILE *fp;
2262 char *i1 = " ", *i2 = " ";
2263 char *indent, *actionline;
104c1213 2264 char tmp[40];
c906108c
SS
2265
2266 if (args == 0 || *args == 0)
2267 error ("Argument required (file name in which to save tracepoints");
2268
2269 if (tracepoint_chain == 0)
2270 {
2271 warning ("save-tracepoints: no tracepoints to save.\n");
2272 return;
2273 }
2274
2275 if (!(fp = fopen (args, "w")))
2276 error ("Unable to open file '%s' for saving tracepoints");
2277
2278 ALL_TRACEPOINTS (tp)
c5aa993b
JM
2279 {
2280 if (tp->addr_string)
2281 fprintf (fp, "trace %s\n", tp->addr_string);
2282 else
104c1213
JM
2283 {
2284 sprintf_vma (tmp, tp->address);
2285 fprintf (fp, "trace *0x%s\n", tmp);
2286 }
c906108c 2287
c5aa993b
JM
2288 if (tp->pass_count)
2289 fprintf (fp, " passcount %d\n", tp->pass_count);
c906108c 2290
c5aa993b
JM
2291 if (tp->actions)
2292 {
2293 fprintf (fp, " actions\n");
2294 indent = i1;
2295 for (line = tp->actions; line; line = line->next)
2296 {
2297 struct cmd_list_element *cmd;
c906108c 2298
c5aa993b
JM
2299 QUIT; /* allow user to bail out with ^C */
2300 actionline = line->action;
104c1213 2301 while (isspace ((int) *actionline))
c5aa993b 2302 actionline++;
c906108c 2303
c5aa993b
JM
2304 fprintf (fp, "%s%s\n", indent, actionline);
2305 if (*actionline != '#') /* skip for comment lines */
2306 {
2307 cmd = lookup_cmd (&actionline, cmdlist, "", -1, 1);
2308 if (cmd == 0)
2309 error ("Bad action list item: %s", actionline);
2310 if (cmd->function.cfunc == while_stepping_pseudocommand)
2311 indent = i2;
2312 else if (cmd->function.cfunc == end_actions_pseudocommand)
2313 indent = i1;
2314 }
2315 }
2316 }
2317 }
c906108c
SS
2318 fclose (fp);
2319 if (from_tty)
2320 printf_filtered ("Tracepoints saved to file '%s'.\n", args);
2321 return;
2322}
2323
2324/* info scope command: list the locals for a scope. */
2325static void
fba45db2 2326scope_info (char *args, int from_tty)
c906108c 2327{
c906108c
SS
2328 struct symtabs_and_lines sals;
2329 struct symbol *sym;
2330 struct minimal_symbol *msym;
2331 struct block *block;
2332 char **canonical, *symname, *save_args = args;
2333 int i, j, nsyms, count = 0;
2334
2335 if (args == 0 || *args == 0)
2336 error ("requires an argument (function, line or *addr) to define a scope");
2337
2338 sals = decode_line_1 (&args, 1, NULL, 0, &canonical);
2339 if (sals.nelts == 0)
c5aa993b 2340 return; /* presumably decode_line_1 has already warned */
c906108c
SS
2341
2342 /* Resolve line numbers to PC */
2343 resolve_sal_pc (&sals.sals[0]);
2344 block = block_for_pc (sals.sals[0].pc);
2345
2346 while (block != 0)
2347 {
c5aa993b 2348 QUIT; /* allow user to bail out with ^C */
c906108c
SS
2349 nsyms = BLOCK_NSYMS (block);
2350 for (i = 0; i < nsyms; i++)
2351 {
c5aa993b 2352 QUIT; /* allow user to bail out with ^C */
c906108c
SS
2353 if (count == 0)
2354 printf_filtered ("Scope for %s:\n", save_args);
2355 count++;
2356 sym = BLOCK_SYM (block, i);
2357 symname = SYMBOL_NAME (sym);
2358 if (symname == NULL || *symname == '\0')
c5aa993b 2359 continue; /* probably botched, certainly useless */
c906108c
SS
2360
2361 printf_filtered ("Symbol %s is ", symname);
c5aa993b
JM
2362 switch (SYMBOL_CLASS (sym))
2363 {
2364 default:
2365 case LOC_UNDEF: /* messed up symbol? */
2366 printf_filtered ("a bogus symbol, class %d.\n",
2367 SYMBOL_CLASS (sym));
2368 count--; /* don't count this one */
2369 continue;
2370 case LOC_CONST:
104c1213 2371 printf_filtered ("a constant with value %ld (0x%lx)",
c5aa993b
JM
2372 SYMBOL_VALUE (sym), SYMBOL_VALUE (sym));
2373 break;
2374 case LOC_CONST_BYTES:
2375 printf_filtered ("constant bytes: ");
2376 if (SYMBOL_TYPE (sym))
2377 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2378 fprintf_filtered (gdb_stdout, " %02x",
2379 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2380 break;
2381 case LOC_STATIC:
2382 printf_filtered ("in static storage at address ");
2383 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, gdb_stdout);
2384 break;
2385 case LOC_REGISTER:
2386 printf_filtered ("a local variable in register $%s",
2387 REGISTER_NAME (SYMBOL_VALUE (sym)));
2388 break;
2389 case LOC_ARG:
2390 case LOC_LOCAL_ARG:
2391 printf_filtered ("an argument at stack/frame offset %ld",
2392 SYMBOL_VALUE (sym));
2393 break;
2394 case LOC_LOCAL:
2395 printf_filtered ("a local variable at frame offset %ld",
2396 SYMBOL_VALUE (sym));
2397 break;
2398 case LOC_REF_ARG:
2399 printf_filtered ("a reference argument at offset %ld",
2400 SYMBOL_VALUE (sym));
2401 break;
2402 case LOC_REGPARM:
2403 printf_filtered ("an argument in register $%s",
2404 REGISTER_NAME (SYMBOL_VALUE (sym)));
2405 break;
2406 case LOC_REGPARM_ADDR:
2407 printf_filtered ("the address of an argument, in register $%s",
2408 REGISTER_NAME (SYMBOL_VALUE (sym)));
2409 break;
2410 case LOC_TYPEDEF:
2411 printf_filtered ("a typedef.\n");
2412 continue;
2413 case LOC_LABEL:
2414 printf_filtered ("a label at address ");
2415 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, gdb_stdout);
2416 break;
2417 case LOC_BLOCK:
2418 printf_filtered ("a function at address ");
2419 print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)), 1,
2420 gdb_stdout);
2421 break;
2422 case LOC_BASEREG:
104c1213 2423 printf_filtered ("a variable at offset %ld from register $%s",
c5aa993b
JM
2424 SYMBOL_VALUE (sym),
2425 REGISTER_NAME (SYMBOL_BASEREG (sym)));
2426 break;
2427 case LOC_BASEREG_ARG:
104c1213 2428 printf_filtered ("an argument at offset %ld from register $%s",
c5aa993b
JM
2429 SYMBOL_VALUE (sym),
2430 REGISTER_NAME (SYMBOL_BASEREG (sym)));
2431 break;
2432 case LOC_UNRESOLVED:
2433 msym = lookup_minimal_symbol (SYMBOL_NAME (sym), NULL, NULL);
2434 if (msym == NULL)
2435 printf_filtered ("Unresolved Static");
2436 else
2437 {
2438 printf_filtered ("static storage at address ");
2439 print_address_numeric (SYMBOL_VALUE_ADDRESS (msym), 1,
2440 gdb_stdout);
2441 }
2442 break;
2443 case LOC_OPTIMIZED_OUT:
2444 printf_filtered ("optimized out.\n");
2445 continue;
2446 }
c906108c 2447 if (SYMBOL_TYPE (sym))
c5aa993b
JM
2448 printf_filtered (", length %d.\n",
2449 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
c906108c
SS
2450 }
2451 if (BLOCK_FUNCTION (block))
2452 break;
2453 else
2454 block = BLOCK_SUPERBLOCK (block);
2455 }
2456 if (count <= 0)
2457 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2458 save_args);
2459}
2460
2461/* worker function (cleanup) */
2462static void
710b33bd 2463replace_comma (void *data)
c906108c 2464{
710b33bd 2465 char *comma = data;
c906108c
SS
2466 *comma = ',';
2467}
2468
2469/* tdump command */
2470static void
fba45db2 2471trace_dump_command (char *args, int from_tty)
c906108c 2472{
c5aa993b 2473 struct tracepoint *t;
c906108c 2474 struct action_line *action;
c5aa993b
JM
2475 char *action_exp, *next_comma;
2476 struct cleanup *old_cleanups;
2477 int stepping_actions = 0;
2478 int stepping_frame = 0;
c906108c
SS
2479
2480 if (!target_is_remote ())
2481 {
2482 error ("Trace can only be run on remote targets.");
2483 return;
2484 }
2485
2486 if (tracepoint_number == -1)
2487 {
2488 warning ("No current trace frame.");
2489 return;
2490 }
2491
2492 ALL_TRACEPOINTS (t)
2493 if (t->number == tracepoint_number)
c5aa993b 2494 break;
c906108c
SS
2495
2496 if (t == NULL)
c5aa993b 2497 error ("No known tracepoint matches 'current' tracepoint #%d.",
c906108c
SS
2498 tracepoint_number);
2499
2500 old_cleanups = make_cleanup (null_cleanup, NULL);
2501
c5aa993b 2502 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
c906108c
SS
2503 tracepoint_number, traceframe_number);
2504
2505 /* The current frame is a trap frame if the frame PC is equal
2506 to the tracepoint PC. If not, then the current frame was
2507 collected during single-stepping. */
2508
c5aa993b 2509 stepping_frame = (t->address != read_pc ());
c906108c
SS
2510
2511 for (action = t->actions; action; action = action->next)
2512 {
2513 struct cmd_list_element *cmd;
2514
c5aa993b 2515 QUIT; /* allow user to bail out with ^C */
c906108c 2516 action_exp = action->action;
104c1213 2517 while (isspace ((int) *action_exp))
c906108c
SS
2518 action_exp++;
2519
2520 /* The collection actions to be done while stepping are
c5aa993b 2521 bracketed by the commands "while-stepping" and "end". */
c906108c
SS
2522
2523 if (*action_exp == '#') /* comment line */
2524 continue;
2525
2526 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2527 if (cmd == 0)
2528 error ("Bad action list item: %s", action_exp);
2529
2530 if (cmd->function.cfunc == while_stepping_pseudocommand)
2531 stepping_actions = 1;
2532 else if (cmd->function.cfunc == end_actions_pseudocommand)
2533 stepping_actions = 0;
2534 else if (cmd->function.cfunc == collect_pseudocommand)
2535 {
2536 /* Display the collected data.
2537 For the trap frame, display only what was collected at the trap.
2538 Likewise for stepping frames, display only what was collected
2539 while stepping. This means that the two boolean variables,
2540 STEPPING_FRAME and STEPPING_ACTIONS should be equal. */
2541 if (stepping_frame == stepping_actions)
2542 {
c5aa993b
JM
2543 do
2544 { /* repeat over a comma-separated list */
2545 QUIT; /* allow user to bail out with ^C */
2546 if (*action_exp == ',')
2547 action_exp++;
104c1213 2548 while (isspace ((int) *action_exp))
c5aa993b
JM
2549 action_exp++;
2550
2551 next_comma = strchr (action_exp, ',');
2552
2553 if (0 == strncasecmp (action_exp, "$reg", 4))
2554 registers_info (NULL, from_tty);
2555 else if (0 == strncasecmp (action_exp, "$loc", 4))
2556 locals_info (NULL, from_tty);
2557 else if (0 == strncasecmp (action_exp, "$arg", 4))
2558 args_info (NULL, from_tty);
2559 else
2560 { /* variable */
2561 if (next_comma)
2562 {
2563 make_cleanup (replace_comma, next_comma);
2564 *next_comma = '\0';
2565 }
2566 printf_filtered ("%s = ", action_exp);
2567 output_command (action_exp, from_tty);
2568 printf_filtered ("\n");
2569 }
2570 if (next_comma)
2571 *next_comma = ',';
2572 action_exp = next_comma;
2573 }
2574 while (action_exp && *action_exp == ',');
c906108c
SS
2575 }
2576 }
2577 }
2578 discard_cleanups (old_cleanups);
2579}
2580
2581/* Convert the memory pointed to by mem into hex, placing result in buf.
2582 * Return a pointer to the last char put in buf (null)
2583 * "stolen" from sparc-stub.c
2584 */
2585
c5aa993b 2586static const char hexchars[] = "0123456789abcdef";
c906108c
SS
2587
2588static unsigned char *
fba45db2 2589mem2hex (unsigned char *mem, unsigned char *buf, int count)
c906108c
SS
2590{
2591 unsigned char ch;
2592
2593 while (count-- > 0)
2594 {
2595 ch = *mem++;
2596
2597 *buf++ = hexchars[ch >> 4];
2598 *buf++ = hexchars[ch & 0xf];
2599 }
2600
2601 *buf = 0;
2602
2603 return buf;
2604}
2605
c5aa993b 2606int
fba45db2 2607get_traceframe_number (void)
c906108c 2608{
c5aa993b 2609 return traceframe_number;
c906108c
SS
2610}
2611
2612
2613/* module initialization */
2614void
fba45db2 2615_initialize_tracepoint (void)
c906108c 2616{
fa58ee11
EZ
2617 struct cmd_list_element *c;
2618
c5aa993b
JM
2619 tracepoint_chain = 0;
2620 tracepoint_count = 0;
c906108c
SS
2621 traceframe_number = -1;
2622 tracepoint_number = -1;
2623
c5aa993b 2624 set_internalvar (lookup_internalvar ("tpnum"),
c906108c 2625 value_from_longest (builtin_type_int, (LONGEST) 0));
c5aa993b
JM
2626 set_internalvar (lookup_internalvar ("trace_frame"),
2627 value_from_longest (builtin_type_int, (LONGEST) - 1));
c906108c
SS
2628
2629 if (tracepoint_list.list == NULL)
2630 {
2631 tracepoint_list.listsize = 128;
c5aa993b 2632 tracepoint_list.list = xmalloc
c906108c
SS
2633 (tracepoint_list.listsize * sizeof (struct memrange));
2634 }
2635 if (tracepoint_list.aexpr_list == NULL)
2636 {
2637 tracepoint_list.aexpr_listsize = 128;
2638 tracepoint_list.aexpr_list = xmalloc
2639 (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
2640 }
2641
2642 if (stepping_list.list == NULL)
2643 {
2644 stepping_list.listsize = 128;
c5aa993b 2645 stepping_list.list = xmalloc
c906108c
SS
2646 (stepping_list.listsize * sizeof (struct memrange));
2647 }
2648
2649 if (stepping_list.aexpr_list == NULL)
2650 {
2651 stepping_list.aexpr_listsize = 128;
2652 stepping_list.aexpr_list = xmalloc
2653 (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
2654 }
2655
c5aa993b 2656 add_info ("scope", scope_info,
c906108c
SS
2657 "List the variables local to a scope");
2658
c5aa993b
JM
2659 add_cmd ("tracepoints", class_trace, NO_FUNCTION,
2660 "Tracing of program execution without stopping the program.",
c906108c
SS
2661 &cmdlist);
2662
2663 add_info ("tracepoints", tracepoints_info,
2664 "Status of tracepoints, or tracepoint number NUMBER.\n\
2665Convenience variable \"$tpnum\" contains the number of the\n\
2666last tracepoint set.");
2667
2668 add_info_alias ("tp", "tracepoints", 1);
2669
fa58ee11
EZ
2670 c = add_com ("save-tracepoints", class_trace, tracepoint_save_command,
2671 "Save current tracepoint definitions as a script.\n\
c906108c 2672Use the 'source' command in another debug session to restore them.");
fa58ee11 2673 c->completer = filename_completer;
c906108c 2674
c5aa993b 2675 add_com ("tdump", class_trace, trace_dump_command,
c906108c
SS
2676 "Print everything collected at the current tracepoint.");
2677
c5aa993b 2678 add_prefix_cmd ("tfind", class_trace, trace_find_command,
c906108c
SS
2679 "Select a trace frame;\n\
2680No argument means forward by one frame; '-' meand backward by one frame.",
2681 &tfindlist, "tfind ", 1, &cmdlist);
2682
2683 add_cmd ("outside", class_trace, trace_find_outside_command,
2684 "Select a trace frame whose PC is outside the given \
c5aa993b 2685range.\nUsage: tfind outside addr1, addr2",
c906108c
SS
2686 &tfindlist);
2687
2688 add_cmd ("range", class_trace, trace_find_range_command,
2689 "Select a trace frame whose PC is in the given range.\n\
c5aa993b 2690Usage: tfind range addr1,addr2",
c906108c
SS
2691 &tfindlist);
2692
2693 add_cmd ("line", class_trace, trace_find_line_command,
2694 "Select a trace frame by source line.\n\
2695Argument can be a line number (with optional source file), \n\
2696a function name, or '*' followed by an address.\n\
2697Default argument is 'the next source line that was traced'.",
2698 &tfindlist);
2699
2700 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command,
2701 "Select a trace frame by tracepoint number.\n\
2702Default is the tracepoint for the current trace frame.",
2703 &tfindlist);
2704
2705 add_cmd ("pc", class_trace, trace_find_pc_command,
2706 "Select a trace frame by PC.\n\
2707Default is the current PC, or the PC of the current trace frame.",
2708 &tfindlist);
2709
2710 add_cmd ("end", class_trace, trace_find_end_command,
2711 "Synonym for 'none'.\n\
2712De-select any trace frame and resume 'live' debugging.",
2713 &tfindlist);
2714
2715 add_cmd ("none", class_trace, trace_find_none_command,
2716 "De-select any trace frame and resume 'live' debugging.",
2717 &tfindlist);
2718
2719 add_cmd ("start", class_trace, trace_find_start_command,
2720 "Select the first trace frame in the trace buffer.",
2721 &tfindlist);
2722
c5aa993b 2723 add_com ("tstatus", class_trace, trace_status_command,
c906108c
SS
2724 "Display the status of the current trace data collection.");
2725
c5aa993b 2726 add_com ("tstop", class_trace, trace_stop_command,
c906108c
SS
2727 "Stop trace data collection.");
2728
2729 add_com ("tstart", class_trace, trace_start_command,
2730 "Start trace data collection.");
2731
c5aa993b 2732 add_com ("passcount", class_trace, trace_pass_command,
c906108c
SS
2733 "Set the passcount for a tracepoint.\n\
2734The trace will end when the tracepoint has been passed 'count' times.\n\
2735Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
2736if TPNUM is omitted, passcount refers to the last tracepoint defined.");
2737
2738 add_com ("end", class_trace, end_actions_pseudocommand,
2739 "Ends a list of commands or actions.\n\
2740Several GDB commands allow you to enter a list of commands or actions.\n\
2741Entering \"end\" on a line by itself is the normal way to terminate\n\
2742such a list.\n\n\
2743Note: the \"end\" command cannot be used at the gdb prompt.");
2744
2745 add_com ("while-stepping", class_trace, while_stepping_pseudocommand,
2746 "Specify single-stepping behavior at a tracepoint.\n\
2747Argument is number of instructions to trace in single-step mode\n\
2748following the tracepoint. This command is normally followed by\n\
2749one or more \"collect\" commands, to specify what to collect\n\
2750while single-stepping.\n\n\
2751Note: this command can only be used in a tracepoint \"actions\" list.");
2752
c5aa993b
JM
2753 add_com_alias ("ws", "while-stepping", class_alias, 0);
2754 add_com_alias ("stepping", "while-stepping", class_alias, 0);
c906108c 2755
c5aa993b 2756 add_com ("collect", class_trace, collect_pseudocommand,
c906108c
SS
2757 "Specify one or more data items to be collected at a tracepoint.\n\
2758Accepts a comma-separated list of (one or more) expressions. GDB will\n\
2759collect all data (variables, registers) referenced by that expression.\n\
2760Also accepts the following special arguments:\n\
2761 $regs -- all registers.\n\
2762 $args -- all function arguments.\n\
2763 $locals -- all variables local to the block/function scope.\n\
2764Note: this command can only be used in a tracepoint \"actions\" list.");
2765
2766 add_com ("actions", class_trace, trace_actions_command,
2767 "Specify the actions to be taken at a tracepoint.\n\
2768Tracepoint actions may include collecting of specified data, \n\
2769single-stepping, or enabling/disabling other tracepoints, \n\
2770depending on target's capabilities.");
2771
c5aa993b 2772 add_cmd ("tracepoints", class_trace, delete_trace_command,
c906108c
SS
2773 "Delete specified tracepoints.\n\
2774Arguments are tracepoint numbers, separated by spaces.\n\
2775No argument means delete all tracepoints.",
2776 &deletelist);
2777
c5aa993b 2778 add_cmd ("tracepoints", class_trace, disable_trace_command,
c906108c
SS
2779 "Disable specified tracepoints.\n\
2780Arguments are tracepoint numbers, separated by spaces.\n\
2781No argument means disable all tracepoints.",
2782 &disablelist);
2783
c5aa993b 2784 add_cmd ("tracepoints", class_trace, enable_trace_command,
c906108c
SS
2785 "Enable specified tracepoints.\n\
2786Arguments are tracepoint numbers, separated by spaces.\n\
2787No argument means enable all tracepoints.",
2788 &enablelist);
2789
c94fdfd0
EZ
2790 c = add_com ("trace", class_trace, trace_command,
2791 "Set a tracepoint at a specified line or function or address.\n\
c906108c
SS
2792Argument may be a line number, function name, or '*' plus an address.\n\
2793For a line number or function, trace at the start of its code.\n\
2794If an address is specified, trace at that exact address.\n\n\
2795Do \"help tracepoints\" for info on other tracepoint commands.");
c94fdfd0 2796 c->completer = location_completer;
c906108c 2797
c5aa993b
JM
2798 add_com_alias ("tp", "trace", class_alias, 0);
2799 add_com_alias ("tr", "trace", class_alias, 1);
2800 add_com_alias ("tra", "trace", class_alias, 1);
c906108c
SS
2801 add_com_alias ("trac", "trace", class_alias, 1);
2802}
This page took 0.409994 seconds and 4 git commands to generate.