1 /* Tracing functionality for remote targets in custom GDB protocol 2 3 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 4 2007, 2008, 2009 Free Software Foundation, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21 #include "defs.h" 22 #include "arch-utils.h" 23 #include "symtab.h" 24 #include "frame.h" 25 #include "gdbtypes.h" 26 #include "expression.h" 27 #include "gdbcmd.h" 28 #include "value.h" 29 #include "target.h" 30 #include "language.h" 31 #include "gdb_string.h" 32 #include "inferior.h" 33 #include "breakpoint.h" 34 #include "tracepoint.h" 35 #include "remote.h" 36 extern int remote_supports_cond_tracepoints (void); 37 #include "linespec.h" 38 #include "regcache.h" 39 #include "completer.h" 40 #include "block.h" 41 #include "dictionary.h" 42 #include "observer.h" 43 #include "user-regs.h" 44 #include "valprint.h" 45 #include "gdbcore.h" 46 #include "objfiles.h" 47 48 #include "ax.h" 49 #include "ax-gdb.h" 50 51 /* readline include files */ 52 #include "readline/readline.h" 53 #include "readline/history.h" 54 55 /* readline defines this. */ 56 #undef savestring 57 58 #ifdef HAVE_UNISTD_H 59 #include <unistd.h> 60 #endif 61 62 /* Maximum length of an agent aexpression. 63 This accounts for the fact that packets are limited to 400 bytes 64 (which includes everything -- including the checksum), and assumes 65 the worst case of maximum length for each of the pieces of a 66 continuation packet. 67 68 NOTE: expressions get mem2hex'ed otherwise this would be twice as 69 large. (400 - 31)/2 == 184 */ 70 #define MAX_AGENT_EXPR_LEN 184 71 72 73 extern void (*deprecated_readline_begin_hook) (char *, ...); 74 extern char *(*deprecated_readline_hook) (char *); 75 extern void (*deprecated_readline_end_hook) (void); 76 77 /* GDB commands implemented in other modules: 78 */ 79 80 extern void output_command (char *, int); 81 82 /* 83 Tracepoint.c: 84 85 This module defines the following debugger commands: 86 trace : set a tracepoint on a function, line, or address. 87 info trace : list all debugger-defined tracepoints. 88 delete trace : delete one or more tracepoints. 89 enable trace : enable one or more tracepoints. 90 disable trace : disable one or more tracepoints. 91 actions : specify actions to be taken at a tracepoint. 92 passcount : specify a pass count for a tracepoint. 93 tstart : start a trace experiment. 94 tstop : stop a trace experiment. 95 tstatus : query the status of a trace experiment. 96 tfind : find a trace frame in the trace buffer. 97 tdump : print everything collected at the current tracepoint. 98 save-tracepoints : write tracepoint setup into a file. 99 100 This module defines the following user-visible debugger variables: 101 $trace_frame : sequence number of trace frame currently being debugged. 102 $trace_line : source line of trace frame currently being debugged. 103 $trace_file : source file of trace frame currently being debugged. 104 $tracepoint : tracepoint number of trace frame currently being debugged. 105 */ 106 107 108 /* ======= Important global variables: ======= */ 109 110 /* Number of last traceframe collected. */ 111 static int traceframe_number; 112 113 /* Tracepoint for last traceframe collected. */ 114 static int tracepoint_number; 115 116 /* Symbol for function for last traceframe collected */ 117 static struct symbol *traceframe_fun; 118 119 /* Symtab and line for last traceframe collected */ 120 static struct symtab_and_line traceframe_sal; 121 122 /* Tracing command lists */ 123 static struct cmd_list_element *tfindlist; 124 125 /* ======= Important command functions: ======= */ 126 static void trace_actions_command (char *, int); 127 static void trace_start_command (char *, int); 128 static void trace_stop_command (char *, int); 129 static void trace_status_command (char *, int); 130 static void trace_find_command (char *, int); 131 static void trace_find_pc_command (char *, int); 132 static void trace_find_tracepoint_command (char *, int); 133 static void trace_find_line_command (char *, int); 134 static void trace_find_range_command (char *, int); 135 static void trace_find_outside_command (char *, int); 136 static void tracepoint_save_command (char *, int); 137 static void trace_dump_command (char *, int); 138 139 /* support routines */ 140 141 struct collection_list; 142 static void add_aexpr (struct collection_list *, struct agent_expr *); 143 static char *mem2hex (gdb_byte *, char *, int); 144 static void add_register (struct collection_list *collection, 145 unsigned int regno); 146 static struct cleanup *make_cleanup_free_actions (struct breakpoint *t); 147 static void free_actions_list (char **actions_list); 148 static void free_actions_list_cleanup_wrapper (void *); 149 150 extern void _initialize_tracepoint (void); 151 152 /* Utility: returns true if "target remote" */ 153 static int 154 target_is_remote (void) 155 { 156 if (current_target.to_shortname && 157 (strcmp (current_target.to_shortname, "remote") == 0 158 || strcmp (current_target.to_shortname, "extended-remote") == 0)) 159 return 1; 160 else 161 return 0; 162 } 163 164 /* Utility: generate error from an incoming stub packet. */ 165 static void 166 trace_error (char *buf) 167 { 168 if (*buf++ != 'E') 169 return; /* not an error msg */ 170 switch (*buf) 171 { 172 case '1': /* malformed packet error */ 173 if (*++buf == '0') /* general case: */ 174 error (_("tracepoint.c: error in outgoing packet.")); 175 else 176 error (_("tracepoint.c: error in outgoing packet at field #%ld."), 177 strtol (buf, NULL, 16)); 178 case '2': 179 error (_("trace API error 0x%s."), ++buf); 180 default: 181 error (_("Target returns error code '%s'."), buf); 182 } 183 } 184 185 /* Utility: wait for reply from stub, while accepting "O" packets. */ 186 static char * 187 remote_get_noisy_reply (char **buf_p, 188 long *sizeof_buf) 189 { 190 do /* Loop on reply from remote stub. */ 191 { 192 char *buf; 193 QUIT; /* allow user to bail out with ^C */ 194 getpkt (buf_p, sizeof_buf, 0); 195 buf = *buf_p; 196 if (buf[0] == 0) 197 error (_("Target does not support this command.")); 198 else if (buf[0] == 'E') 199 trace_error (buf); 200 else if (buf[0] == 'O' && 201 buf[1] != 'K') 202 remote_console_output (buf + 1); /* 'O' message from stub */ 203 else 204 return buf; /* here's the actual reply */ 205 } 206 while (1); 207 } 208 209 /* Set traceframe number to NUM. */ 210 static void 211 set_traceframe_num (int num) 212 { 213 traceframe_number = num; 214 set_internalvar_integer (lookup_internalvar ("trace_frame"), num); 215 } 216 217 /* Set tracepoint number to NUM. */ 218 static void 219 set_tracepoint_num (int num) 220 { 221 tracepoint_number = num; 222 set_internalvar_integer (lookup_internalvar ("tracepoint"), num); 223 } 224 225 /* Set externally visible debug variables for querying/printing 226 the traceframe context (line, function, file) */ 227 228 static void 229 set_traceframe_context (struct frame_info *trace_frame) 230 { 231 CORE_ADDR trace_pc; 232 233 if (trace_frame == NULL) /* Cease debugging any trace buffers. */ 234 { 235 traceframe_fun = 0; 236 traceframe_sal.pc = traceframe_sal.line = 0; 237 traceframe_sal.symtab = NULL; 238 clear_internalvar (lookup_internalvar ("trace_func")); 239 clear_internalvar (lookup_internalvar ("trace_file")); 240 set_internalvar_integer (lookup_internalvar ("trace_line"), -1); 241 return; 242 } 243 244 /* Save as globals for internal use. */ 245 trace_pc = get_frame_pc (trace_frame); 246 traceframe_sal = find_pc_line (trace_pc, 0); 247 traceframe_fun = find_pc_function (trace_pc); 248 249 /* Save linenumber as "$trace_line", a debugger variable visible to 250 users. */ 251 set_internalvar_integer (lookup_internalvar ("trace_line"), 252 traceframe_sal.line); 253 254 /* Save func name as "$trace_func", a debugger variable visible to 255 users. */ 256 if (traceframe_fun == NULL 257 || SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL) 258 clear_internalvar (lookup_internalvar ("trace_func")); 259 else 260 set_internalvar_string (lookup_internalvar ("trace_func"), 261 SYMBOL_LINKAGE_NAME (traceframe_fun)); 262 263 /* Save file name as "$trace_file", a debugger variable visible to 264 users. */ 265 if (traceframe_sal.symtab == NULL 266 || traceframe_sal.symtab->filename == NULL) 267 clear_internalvar (lookup_internalvar ("trace_file")); 268 else 269 set_internalvar_string (lookup_internalvar ("trace_file"), 270 traceframe_sal.symtab->filename); 271 } 272 273 /* ACTIONS functions: */ 274 275 /* Prototypes for action-parsing utility commands */ 276 static void read_actions (struct breakpoint *); 277 278 /* The three functions: 279 collect_pseudocommand, 280 while_stepping_pseudocommand, and 281 end_actions_pseudocommand 282 are placeholders for "commands" that are actually ONLY to be used 283 within a tracepoint action list. If the actual function is ever called, 284 it means that somebody issued the "command" at the top level, 285 which is always an error. */ 286 287 void 288 end_actions_pseudocommand (char *args, int from_tty) 289 { 290 error (_("This command cannot be used at the top level.")); 291 } 292 293 void 294 while_stepping_pseudocommand (char *args, int from_tty) 295 { 296 error (_("This command can only be used in a tracepoint actions list.")); 297 } 298 299 static void 300 collect_pseudocommand (char *args, int from_tty) 301 { 302 error (_("This command can only be used in a tracepoint actions list.")); 303 } 304 305 /* Enter a list of actions for a tracepoint. */ 306 static void 307 trace_actions_command (char *args, int from_tty) 308 { 309 struct breakpoint *t; 310 char tmpbuf[128]; 311 char *end_msg = "End with a line saying just \"end\"."; 312 313 t = get_tracepoint_by_number (&args, 0, 1); 314 if (t) 315 { 316 sprintf (tmpbuf, "Enter actions for tracepoint %d, one per line.", 317 t->number); 318 319 if (from_tty) 320 { 321 if (deprecated_readline_begin_hook) 322 (*deprecated_readline_begin_hook) ("%s %s\n", tmpbuf, end_msg); 323 else if (input_from_terminal_p ()) 324 printf_filtered ("%s\n%s\n", tmpbuf, end_msg); 325 } 326 327 free_actions (t); 328 t->step_count = 0; /* read_actions may set this */ 329 read_actions (t); 330 331 if (deprecated_readline_end_hook) 332 (*deprecated_readline_end_hook) (); 333 /* tracepoints_changed () */ 334 } 335 /* else just return */ 336 } 337 338 /* worker function */ 339 static void 340 read_actions (struct breakpoint *t) 341 { 342 char *line; 343 char *prompt1 = "> ", *prompt2 = " > "; 344 char *prompt = prompt1; 345 enum actionline_type linetype; 346 extern FILE *instream; 347 struct action_line *next = NULL, *temp; 348 struct cleanup *old_chain; 349 350 /* Control-C quits instantly if typed while in this loop 351 since it should not wait until the user types a newline. */ 352 immediate_quit++; 353 /* FIXME: kettenis/20010823: Something is wrong here. In this file 354 STOP_SIGNAL is never defined. So this code has been left out, at 355 least for quite a while now. Replacing STOP_SIGNAL with SIGTSTP 356 leads to compilation failures since the variable job_control 357 isn't declared. Leave this alone for now. */ 358 #ifdef STOP_SIGNAL 359 if (job_control) 360 signal (STOP_SIGNAL, handle_stop_sig); 361 #endif 362 old_chain = make_cleanup_free_actions (t); 363 while (1) 364 { 365 /* Make sure that all output has been output. Some machines may 366 let you get away with leaving out some of the gdb_flush, but 367 not all. */ 368 wrap_here (""); 369 gdb_flush (gdb_stdout); 370 gdb_flush (gdb_stderr); 371 372 if (deprecated_readline_hook && instream == NULL) 373 line = (*deprecated_readline_hook) (prompt); 374 else if (instream == stdin && ISATTY (instream)) 375 { 376 line = gdb_readline_wrapper (prompt); 377 if (line && *line) /* add it to command history */ 378 add_history (line); 379 } 380 else 381 line = gdb_readline (0); 382 383 if (!line) 384 { 385 line = xstrdup ("end"); 386 printf_filtered ("end\n"); 387 } 388 389 linetype = validate_actionline (&line, t); 390 if (linetype == BADLINE) 391 continue; /* already warned -- collect another line */ 392 393 temp = xmalloc (sizeof (struct action_line)); 394 temp->next = NULL; 395 temp->action = line; 396 397 if (next == NULL) /* first action for this tracepoint? */ 398 t->actions = next = temp; 399 else 400 { 401 next->next = temp; 402 next = temp; 403 } 404 405 if (linetype == STEPPING) /* begin "while-stepping" */ 406 { 407 if (prompt == prompt2) 408 { 409 warning (_("Already processing 'while-stepping'")); 410 continue; 411 } 412 else 413 prompt = prompt2; /* change prompt for stepping actions */ 414 } 415 else if (linetype == END) 416 { 417 if (prompt == prompt2) 418 { 419 prompt = prompt1; /* end of single-stepping actions */ 420 } 421 else 422 { /* end of actions */ 423 if (t->actions->next == NULL) 424 { 425 /* An "end" all by itself with no other actions 426 means this tracepoint has no actions. 427 Discard empty list. */ 428 free_actions (t); 429 } 430 break; 431 } 432 } 433 } 434 #ifdef STOP_SIGNAL 435 if (job_control) 436 signal (STOP_SIGNAL, SIG_DFL); 437 #endif 438 immediate_quit--; 439 discard_cleanups (old_chain); 440 } 441 442 /* worker function */ 443 enum actionline_type 444 validate_actionline (char **line, struct breakpoint *t) 445 { 446 struct cmd_list_element *c; 447 struct expression *exp = NULL; 448 struct cleanup *old_chain = NULL; 449 char *p; 450 451 /* if EOF is typed, *line is NULL */ 452 if (*line == NULL) 453 return END; 454 455 for (p = *line; isspace ((int) *p);) 456 p++; 457 458 /* Symbol lookup etc. */ 459 if (*p == '\0') /* empty line: just prompt for another line. */ 460 return BADLINE; 461 462 if (*p == '#') /* comment line */ 463 return GENERIC; 464 465 c = lookup_cmd (&p, cmdlist, "", -1, 1); 466 if (c == 0) 467 { 468 warning (_("'%s' is not an action that I know, or is ambiguous."), 469 p); 470 return BADLINE; 471 } 472 473 if (cmd_cfunc_eq (c, collect_pseudocommand)) 474 { 475 struct agent_expr *aexpr; 476 struct agent_reqs areqs; 477 478 do 479 { /* repeat over a comma-separated list */ 480 QUIT; /* allow user to bail out with ^C */ 481 while (isspace ((int) *p)) 482 p++; 483 484 if (*p == '$') /* look for special pseudo-symbols */ 485 { 486 if ((0 == strncasecmp ("reg", p + 1, 3)) || 487 (0 == strncasecmp ("arg", p + 1, 3)) || 488 (0 == strncasecmp ("loc", p + 1, 3))) 489 { 490 p = strchr (p, ','); 491 continue; 492 } 493 /* else fall thru, treat p as an expression and parse it! */ 494 } 495 exp = parse_exp_1 (&p, block_for_pc (t->loc->address), 1); 496 old_chain = make_cleanup (free_current_contents, &exp); 497 498 if (exp->elts[0].opcode == OP_VAR_VALUE) 499 { 500 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST) 501 { 502 warning (_("constant %s (value %ld) will not be collected."), 503 SYMBOL_PRINT_NAME (exp->elts[2].symbol), 504 SYMBOL_VALUE (exp->elts[2].symbol)); 505 return BADLINE; 506 } 507 else if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_OPTIMIZED_OUT) 508 { 509 warning (_("%s is optimized away and cannot be collected."), 510 SYMBOL_PRINT_NAME (exp->elts[2].symbol)); 511 return BADLINE; 512 } 513 } 514 515 /* We have something to collect, make sure that the expr to 516 bytecode translator can handle it and that it's not too 517 long. */ 518 aexpr = gen_trace_for_expr (t->loc->address, exp); 519 make_cleanup_free_agent_expr (aexpr); 520 521 if (aexpr->len > MAX_AGENT_EXPR_LEN) 522 error (_("expression too complicated, try simplifying")); 523 524 ax_reqs (aexpr, &areqs); 525 (void) make_cleanup (xfree, areqs.reg_mask); 526 527 if (areqs.flaw != agent_flaw_none) 528 error (_("malformed expression")); 529 530 if (areqs.min_height < 0) 531 error (_("gdb: Internal error: expression has min height < 0")); 532 533 if (areqs.max_height > 20) 534 error (_("expression too complicated, try simplifying")); 535 536 do_cleanups (old_chain); 537 } 538 while (p && *p++ == ','); 539 return GENERIC; 540 } 541 else if (cmd_cfunc_eq (c, while_stepping_pseudocommand)) 542 { 543 char *steparg; /* in case warning is necessary */ 544 545 while (isspace ((int) *p)) 546 p++; 547 steparg = p; 548 549 if (*p == '\0' || 550 (t->step_count = strtol (p, &p, 0)) == 0) 551 { 552 warning (_("'%s': bad step-count; command ignored."), *line); 553 return BADLINE; 554 } 555 return STEPPING; 556 } 557 else if (cmd_cfunc_eq (c, end_actions_pseudocommand)) 558 return END; 559 else 560 { 561 warning (_("'%s' is not a supported tracepoint action."), *line); 562 return BADLINE; 563 } 564 } 565 566 /* worker function */ 567 void 568 free_actions (struct breakpoint *t) 569 { 570 struct action_line *line, *next; 571 572 for (line = t->actions; line; line = next) 573 { 574 next = line->next; 575 if (line->action) 576 xfree (line->action); 577 xfree (line); 578 } 579 t->actions = NULL; 580 } 581 582 static void 583 do_free_actions_cleanup (void *t) 584 { 585 free_actions (t); 586 } 587 588 static struct cleanup * 589 make_cleanup_free_actions (struct breakpoint *t) 590 { 591 return make_cleanup (do_free_actions_cleanup, t); 592 } 593 594 enum { 595 memrange_absolute = -1 596 }; 597 598 struct memrange 599 { 600 int type; /* memrange_absolute for absolute memory range, 601 else basereg number */ 602 bfd_signed_vma start; 603 bfd_signed_vma end; 604 }; 605 606 struct collection_list 607 { 608 unsigned char regs_mask[32]; /* room for up to 256 regs */ 609 long listsize; 610 long next_memrange; 611 struct memrange *list; 612 long aexpr_listsize; /* size of array pointed to by expr_list elt */ 613 long next_aexpr_elt; 614 struct agent_expr **aexpr_list; 615 616 } 617 tracepoint_list, stepping_list; 618 619 /* MEMRANGE functions: */ 620 621 static int memrange_cmp (const void *, const void *); 622 623 /* compare memranges for qsort */ 624 static int 625 memrange_cmp (const void *va, const void *vb) 626 { 627 const struct memrange *a = va, *b = vb; 628 629 if (a->type < b->type) 630 return -1; 631 if (a->type > b->type) 632 return 1; 633 if (a->type == memrange_absolute) 634 { 635 if ((bfd_vma) a->start < (bfd_vma) b->start) 636 return -1; 637 if ((bfd_vma) a->start > (bfd_vma) b->start) 638 return 1; 639 } 640 else 641 { 642 if (a->start < b->start) 643 return -1; 644 if (a->start > b->start) 645 return 1; 646 } 647 return 0; 648 } 649 650 /* Sort the memrange list using qsort, and merge adjacent memranges. */ 651 static void 652 memrange_sortmerge (struct collection_list *memranges) 653 { 654 int a, b; 655 656 qsort (memranges->list, memranges->next_memrange, 657 sizeof (struct memrange), memrange_cmp); 658 if (memranges->next_memrange > 0) 659 { 660 for (a = 0, b = 1; b < memranges->next_memrange; b++) 661 { 662 if (memranges->list[a].type == memranges->list[b].type && 663 memranges->list[b].start - memranges->list[a].end <= 664 MAX_REGISTER_SIZE) 665 { 666 /* memrange b starts before memrange a ends; merge them. */ 667 if (memranges->list[b].end > memranges->list[a].end) 668 memranges->list[a].end = memranges->list[b].end; 669 continue; /* next b, same a */ 670 } 671 a++; /* next a */ 672 if (a != b) 673 memcpy (&memranges->list[a], &memranges->list[b], 674 sizeof (struct memrange)); 675 } 676 memranges->next_memrange = a + 1; 677 } 678 } 679 680 /* Add a register to a collection list. */ 681 static void 682 add_register (struct collection_list *collection, unsigned int regno) 683 { 684 if (info_verbose) 685 printf_filtered ("collect register %d\n", regno); 686 if (regno >= (8 * sizeof (collection->regs_mask))) 687 error (_("Internal: register number %d too large for tracepoint"), 688 regno); 689 collection->regs_mask[regno / 8] |= 1 << (regno % 8); 690 } 691 692 /* Add a memrange to a collection list */ 693 static void 694 add_memrange (struct collection_list *memranges, 695 int type, bfd_signed_vma base, 696 unsigned long len) 697 { 698 if (info_verbose) 699 { 700 printf_filtered ("(%d,", type); 701 printf_vma (base); 702 printf_filtered (",%ld)\n", len); 703 } 704 705 /* type: memrange_absolute == memory, other n == basereg */ 706 memranges->list[memranges->next_memrange].type = type; 707 /* base: addr if memory, offset if reg relative. */ 708 memranges->list[memranges->next_memrange].start = base; 709 /* len: we actually save end (base + len) for convenience */ 710 memranges->list[memranges->next_memrange].end = base + len; 711 memranges->next_memrange++; 712 if (memranges->next_memrange >= memranges->listsize) 713 { 714 memranges->listsize *= 2; 715 memranges->list = xrealloc (memranges->list, 716 memranges->listsize); 717 } 718 719 if (type != memrange_absolute) /* Better collect the base register! */ 720 add_register (memranges, type); 721 } 722 723 /* Add a symbol to a collection list. */ 724 static void 725 collect_symbol (struct collection_list *collect, 726 struct symbol *sym, 727 struct gdbarch *gdbarch, 728 long frame_regno, long frame_offset) 729 { 730 unsigned long len; 731 unsigned int reg; 732 bfd_signed_vma offset; 733 734 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))); 735 switch (SYMBOL_CLASS (sym)) 736 { 737 default: 738 printf_filtered ("%s: don't know symbol class %d\n", 739 SYMBOL_PRINT_NAME (sym), 740 SYMBOL_CLASS (sym)); 741 break; 742 case LOC_CONST: 743 printf_filtered ("constant %s (value %ld) will not be collected.\n", 744 SYMBOL_PRINT_NAME (sym), SYMBOL_VALUE (sym)); 745 break; 746 case LOC_STATIC: 747 offset = SYMBOL_VALUE_ADDRESS (sym); 748 if (info_verbose) 749 { 750 char tmp[40]; 751 752 sprintf_vma (tmp, offset); 753 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n", 754 SYMBOL_PRINT_NAME (sym), len, 755 tmp /* address */); 756 } 757 add_memrange (collect, memrange_absolute, offset, len); 758 break; 759 case LOC_REGISTER: 760 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch); 761 if (info_verbose) 762 printf_filtered ("LOC_REG[parm] %s: ", 763 SYMBOL_PRINT_NAME (sym)); 764 add_register (collect, reg); 765 /* Check for doubles stored in two registers. */ 766 /* FIXME: how about larger types stored in 3 or more regs? */ 767 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT && 768 len > register_size (gdbarch, reg)) 769 add_register (collect, reg + 1); 770 break; 771 case LOC_REF_ARG: 772 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n"); 773 printf_filtered (" (will not collect %s)\n", 774 SYMBOL_PRINT_NAME (sym)); 775 break; 776 case LOC_ARG: 777 reg = frame_regno; 778 offset = frame_offset + SYMBOL_VALUE (sym); 779 if (info_verbose) 780 { 781 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ", 782 SYMBOL_PRINT_NAME (sym), len); 783 printf_vma (offset); 784 printf_filtered (" from frame ptr reg %d\n", reg); 785 } 786 add_memrange (collect, reg, offset, len); 787 break; 788 case LOC_REGPARM_ADDR: 789 reg = SYMBOL_VALUE (sym); 790 offset = 0; 791 if (info_verbose) 792 { 793 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ", 794 SYMBOL_PRINT_NAME (sym), len); 795 printf_vma (offset); 796 printf_filtered (" from reg %d\n", reg); 797 } 798 add_memrange (collect, reg, offset, len); 799 break; 800 case LOC_LOCAL: 801 reg = frame_regno; 802 offset = frame_offset + SYMBOL_VALUE (sym); 803 if (info_verbose) 804 { 805 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ", 806 SYMBOL_PRINT_NAME (sym), len); 807 printf_vma (offset); 808 printf_filtered (" from frame ptr reg %d\n", reg); 809 } 810 add_memrange (collect, reg, offset, len); 811 break; 812 case LOC_UNRESOLVED: 813 printf_filtered ("Don't know LOC_UNRESOLVED %s\n", 814 SYMBOL_PRINT_NAME (sym)); 815 break; 816 case LOC_OPTIMIZED_OUT: 817 printf_filtered ("%s has been optimized out of existence.\n", 818 SYMBOL_PRINT_NAME (sym)); 819 break; 820 } 821 } 822 823 /* Add all locals (or args) symbols to collection list */ 824 static void 825 add_local_symbols (struct collection_list *collect, 826 struct gdbarch *gdbarch, CORE_ADDR pc, 827 long frame_regno, long frame_offset, int type) 828 { 829 struct symbol *sym; 830 struct block *block; 831 struct dict_iterator iter; 832 int count = 0; 833 834 block = block_for_pc (pc); 835 while (block != 0) 836 { 837 QUIT; /* allow user to bail out with ^C */ 838 ALL_BLOCK_SYMBOLS (block, iter, sym) 839 { 840 if (SYMBOL_IS_ARGUMENT (sym) 841 ? type == 'A' /* collecting Arguments */ 842 : type == 'L') /* collecting Locals */ 843 { 844 count++; 845 collect_symbol (collect, sym, gdbarch, 846 frame_regno, frame_offset); 847 } 848 } 849 if (BLOCK_FUNCTION (block)) 850 break; 851 else 852 block = BLOCK_SUPERBLOCK (block); 853 } 854 if (count == 0) 855 warning (_("No %s found in scope."), 856 type == 'L' ? "locals" : "args"); 857 } 858 859 /* worker function */ 860 static void 861 clear_collection_list (struct collection_list *list) 862 { 863 int ndx; 864 865 list->next_memrange = 0; 866 for (ndx = 0; ndx < list->next_aexpr_elt; ndx++) 867 { 868 free_agent_expr (list->aexpr_list[ndx]); 869 list->aexpr_list[ndx] = NULL; 870 } 871 list->next_aexpr_elt = 0; 872 memset (list->regs_mask, 0, sizeof (list->regs_mask)); 873 } 874 875 /* reduce a collection list to string form (for gdb protocol) */ 876 static char ** 877 stringify_collection_list (struct collection_list *list, char *string) 878 { 879 char temp_buf[2048]; 880 char tmp2[40]; 881 int count; 882 int ndx = 0; 883 char *(*str_list)[]; 884 char *end; 885 long i; 886 887 count = 1 + list->next_memrange + list->next_aexpr_elt + 1; 888 str_list = (char *(*)[]) xmalloc (count * sizeof (char *)); 889 890 for (i = sizeof (list->regs_mask) - 1; i > 0; i--) 891 if (list->regs_mask[i] != 0) /* skip leading zeroes in regs_mask */ 892 break; 893 if (list->regs_mask[i] != 0) /* prepare to send regs_mask to the stub */ 894 { 895 if (info_verbose) 896 printf_filtered ("\nCollecting registers (mask): 0x"); 897 end = temp_buf; 898 *end++ = 'R'; 899 for (; i >= 0; i--) 900 { 901 QUIT; /* allow user to bail out with ^C */ 902 if (info_verbose) 903 printf_filtered ("%02X", list->regs_mask[i]); 904 sprintf (end, "%02X", list->regs_mask[i]); 905 end += 2; 906 } 907 (*str_list)[ndx] = xstrdup (temp_buf); 908 ndx++; 909 } 910 if (info_verbose) 911 printf_filtered ("\n"); 912 if (list->next_memrange > 0 && info_verbose) 913 printf_filtered ("Collecting memranges: \n"); 914 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++) 915 { 916 QUIT; /* allow user to bail out with ^C */ 917 sprintf_vma (tmp2, list->list[i].start); 918 if (info_verbose) 919 { 920 printf_filtered ("(%d, %s, %ld)\n", 921 list->list[i].type, 922 tmp2, 923 (long) (list->list[i].end - list->list[i].start)); 924 } 925 if (count + 27 > MAX_AGENT_EXPR_LEN) 926 { 927 (*str_list)[ndx] = savestring (temp_buf, count); 928 ndx++; 929 count = 0; 930 end = temp_buf; 931 } 932 933 { 934 bfd_signed_vma length = list->list[i].end - list->list[i].start; 935 936 /* The "%X" conversion specifier expects an unsigned argument, 937 so passing -1 (memrange_absolute) to it directly gives you 938 "FFFFFFFF" (or more, depending on sizeof (unsigned)). 939 Special-case it. */ 940 if (list->list[i].type == memrange_absolute) 941 sprintf (end, "M-1,%s,%lX", tmp2, (long) length); 942 else 943 sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length); 944 } 945 946 count += strlen (end); 947 end = temp_buf + count; 948 } 949 950 for (i = 0; i < list->next_aexpr_elt; i++) 951 { 952 QUIT; /* allow user to bail out with ^C */ 953 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN) 954 { 955 (*str_list)[ndx] = savestring (temp_buf, count); 956 ndx++; 957 count = 0; 958 end = temp_buf; 959 } 960 sprintf (end, "X%08X,", list->aexpr_list[i]->len); 961 end += 10; /* 'X' + 8 hex digits + ',' */ 962 count += 10; 963 964 end = mem2hex (list->aexpr_list[i]->buf, 965 end, list->aexpr_list[i]->len); 966 count += 2 * list->aexpr_list[i]->len; 967 } 968 969 if (count != 0) 970 { 971 (*str_list)[ndx] = savestring (temp_buf, count); 972 ndx++; 973 count = 0; 974 end = temp_buf; 975 } 976 (*str_list)[ndx] = NULL; 977 978 if (ndx == 0) 979 { 980 xfree (str_list); 981 return NULL; 982 } 983 else 984 return *str_list; 985 } 986 987 static void 988 free_actions_list_cleanup_wrapper (void *al) 989 { 990 free_actions_list (al); 991 } 992 993 static void 994 free_actions_list (char **actions_list) 995 { 996 int ndx; 997 998 if (actions_list == 0) 999 return; 1000 1001 for (ndx = 0; actions_list[ndx]; ndx++) 1002 xfree (actions_list[ndx]); 1003 1004 xfree (actions_list); 1005 } 1006 1007 /* Render all actions into gdb protocol. */ 1008 static void 1009 encode_actions (struct breakpoint *t, char ***tdp_actions, 1010 char ***stepping_actions) 1011 { 1012 static char tdp_buff[2048], step_buff[2048]; 1013 char *action_exp; 1014 struct expression *exp = NULL; 1015 struct action_line *action; 1016 int i; 1017 struct value *tempval; 1018 struct collection_list *collect; 1019 struct cmd_list_element *cmd; 1020 struct agent_expr *aexpr; 1021 int frame_reg; 1022 LONGEST frame_offset; 1023 1024 1025 clear_collection_list (&tracepoint_list); 1026 clear_collection_list (&stepping_list); 1027 collect = &tracepoint_list; 1028 1029 *tdp_actions = NULL; 1030 *stepping_actions = NULL; 1031 1032 gdbarch_virtual_frame_pointer (t->gdbarch, 1033 t->loc->address, &frame_reg, &frame_offset); 1034 1035 for (action = t->actions; action; action = action->next) 1036 { 1037 QUIT; /* allow user to bail out with ^C */ 1038 action_exp = action->action; 1039 while (isspace ((int) *action_exp)) 1040 action_exp++; 1041 1042 if (*action_exp == '#') /* comment line */ 1043 return; 1044 1045 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1); 1046 if (cmd == 0) 1047 error (_("Bad action list item: %s"), action_exp); 1048 1049 if (cmd_cfunc_eq (cmd, collect_pseudocommand)) 1050 { 1051 do 1052 { /* repeat over a comma-separated list */ 1053 QUIT; /* allow user to bail out with ^C */ 1054 while (isspace ((int) *action_exp)) 1055 action_exp++; 1056 1057 if (0 == strncasecmp ("$reg", action_exp, 4)) 1058 { 1059 for (i = 0; i < gdbarch_num_regs (t->gdbarch); i++) 1060 add_register (collect, i); 1061 action_exp = strchr (action_exp, ','); /* more? */ 1062 } 1063 else if (0 == strncasecmp ("$arg", action_exp, 4)) 1064 { 1065 add_local_symbols (collect, 1066 t->gdbarch, 1067 t->loc->address, 1068 frame_reg, 1069 frame_offset, 1070 'A'); 1071 action_exp = strchr (action_exp, ','); /* more? */ 1072 } 1073 else if (0 == strncasecmp ("$loc", action_exp, 4)) 1074 { 1075 add_local_symbols (collect, 1076 t->gdbarch, 1077 t->loc->address, 1078 frame_reg, 1079 frame_offset, 1080 'L'); 1081 action_exp = strchr (action_exp, ','); /* more? */ 1082 } 1083 else 1084 { 1085 unsigned long addr, len; 1086 struct cleanup *old_chain = NULL; 1087 struct cleanup *old_chain1 = NULL; 1088 struct agent_reqs areqs; 1089 1090 exp = parse_exp_1 (&action_exp, 1091 block_for_pc (t->loc->address), 1); 1092 old_chain = make_cleanup (free_current_contents, &exp); 1093 1094 switch (exp->elts[0].opcode) 1095 { 1096 case OP_REGISTER: 1097 { 1098 const char *name = &exp->elts[2].string; 1099 1100 i = user_reg_map_name_to_regnum (t->gdbarch, 1101 name, strlen (name)); 1102 if (i == -1) 1103 internal_error (__FILE__, __LINE__, 1104 _("Register $%s not available"), 1105 name); 1106 if (info_verbose) 1107 printf_filtered ("OP_REGISTER: "); 1108 add_register (collect, i); 1109 break; 1110 } 1111 1112 case UNOP_MEMVAL: 1113 /* safe because we know it's a simple expression */ 1114 tempval = evaluate_expression (exp); 1115 addr = value_address (tempval); 1116 len = TYPE_LENGTH (check_typedef (exp->elts[1].type)); 1117 add_memrange (collect, memrange_absolute, addr, len); 1118 break; 1119 1120 case OP_VAR_VALUE: 1121 collect_symbol (collect, 1122 exp->elts[2].symbol, 1123 t->gdbarch, 1124 frame_reg, 1125 frame_offset); 1126 break; 1127 1128 default: /* full-fledged expression */ 1129 aexpr = gen_trace_for_expr (t->loc->address, exp); 1130 1131 old_chain1 = make_cleanup_free_agent_expr (aexpr); 1132 1133 ax_reqs (aexpr, &areqs); 1134 if (areqs.flaw != agent_flaw_none) 1135 error (_("malformed expression")); 1136 1137 if (areqs.min_height < 0) 1138 error (_("gdb: Internal error: expression has min height < 0")); 1139 if (areqs.max_height > 20) 1140 error (_("expression too complicated, try simplifying")); 1141 1142 discard_cleanups (old_chain1); 1143 add_aexpr (collect, aexpr); 1144 1145 /* take care of the registers */ 1146 if (areqs.reg_mask_len > 0) 1147 { 1148 int ndx1; 1149 int ndx2; 1150 1151 for (ndx1 = 0; ndx1 < areqs.reg_mask_len; ndx1++) 1152 { 1153 QUIT; /* allow user to bail out with ^C */ 1154 if (areqs.reg_mask[ndx1] != 0) 1155 { 1156 /* assume chars have 8 bits */ 1157 for (ndx2 = 0; ndx2 < 8; ndx2++) 1158 if (areqs.reg_mask[ndx1] & (1 << ndx2)) 1159 /* it's used -- record it */ 1160 add_register (collect, 1161 ndx1 * 8 + ndx2); 1162 } 1163 } 1164 } 1165 break; 1166 } /* switch */ 1167 do_cleanups (old_chain); 1168 } /* do */ 1169 } 1170 while (action_exp && *action_exp++ == ','); 1171 } /* if */ 1172 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand)) 1173 { 1174 collect = &stepping_list; 1175 } 1176 else if (cmd_cfunc_eq (cmd, end_actions_pseudocommand)) 1177 { 1178 if (collect == &stepping_list) /* end stepping actions */ 1179 collect = &tracepoint_list; 1180 else 1181 break; /* end tracepoint actions */ 1182 } 1183 } /* for */ 1184 memrange_sortmerge (&tracepoint_list); 1185 memrange_sortmerge (&stepping_list); 1186 1187 *tdp_actions = stringify_collection_list (&tracepoint_list, 1188 tdp_buff); 1189 *stepping_actions = stringify_collection_list (&stepping_list, 1190 step_buff); 1191 } 1192 1193 static void 1194 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr) 1195 { 1196 if (collect->next_aexpr_elt >= collect->aexpr_listsize) 1197 { 1198 collect->aexpr_list = 1199 xrealloc (collect->aexpr_list, 1200 2 * collect->aexpr_listsize * sizeof (struct agent_expr *)); 1201 collect->aexpr_listsize *= 2; 1202 } 1203 collect->aexpr_list[collect->next_aexpr_elt] = aexpr; 1204 collect->next_aexpr_elt++; 1205 } 1206 1207 static char *target_buf; 1208 static long target_buf_size; 1209 1210 /* Set "transparent" memory ranges 1211 1212 Allow trace mechanism to treat text-like sections 1213 (and perhaps all read-only sections) transparently, 1214 i.e. don't reject memory requests from these address ranges 1215 just because they haven't been collected. */ 1216 1217 static void 1218 remote_set_transparent_ranges (void) 1219 { 1220 asection *s; 1221 bfd_size_type size; 1222 bfd_vma lma; 1223 int anysecs = 0; 1224 1225 if (!exec_bfd) 1226 return; /* No information to give. */ 1227 1228 strcpy (target_buf, "QTro"); 1229 for (s = exec_bfd->sections; s; s = s->next) 1230 { 1231 char tmp1[40], tmp2[40]; 1232 1233 if ((s->flags & SEC_LOAD) == 0 || 1234 /* (s->flags & SEC_CODE) == 0 || */ 1235 (s->flags & SEC_READONLY) == 0) 1236 continue; 1237 1238 anysecs = 1; 1239 lma = s->lma; 1240 size = bfd_get_section_size (s); 1241 sprintf_vma (tmp1, lma); 1242 sprintf_vma (tmp2, lma + size); 1243 sprintf (target_buf + strlen (target_buf), 1244 ":%s,%s", tmp1, tmp2); 1245 } 1246 if (anysecs) 1247 { 1248 putpkt (target_buf); 1249 getpkt (&target_buf, &target_buf_size, 0); 1250 } 1251 } 1252 1253 /* tstart command: 1254 1255 Tell target to clear any previous trace experiment. 1256 Walk the list of tracepoints, and send them (and their actions) 1257 to the target. If no errors, 1258 Tell target to start a new trace experiment. */ 1259 1260 void download_tracepoint (struct breakpoint *t); 1261 1262 static void 1263 trace_start_command (char *args, int from_tty) 1264 { 1265 VEC(breakpoint_p) *tp_vec = NULL; 1266 int ix; 1267 struct breakpoint *t; 1268 1269 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */ 1270 1271 if (target_is_remote ()) 1272 { 1273 putpkt ("QTinit"); 1274 remote_get_noisy_reply (&target_buf, &target_buf_size); 1275 if (strcmp (target_buf, "OK")) 1276 error (_("Target does not support this command.")); 1277 1278 tp_vec = all_tracepoints (); 1279 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++) 1280 { 1281 download_tracepoint (t); 1282 } 1283 VEC_free (breakpoint_p, tp_vec); 1284 1285 /* Tell target to treat text-like sections as transparent. */ 1286 remote_set_transparent_ranges (); 1287 /* Now insert traps and begin collecting data. */ 1288 putpkt ("QTStart"); 1289 remote_get_noisy_reply (&target_buf, &target_buf_size); 1290 if (strcmp (target_buf, "OK")) 1291 error (_("Bogus reply from target: %s"), target_buf); 1292 set_traceframe_num (-1); /* All old traceframes invalidated. */ 1293 set_tracepoint_num (-1); 1294 set_traceframe_context (NULL); 1295 trace_running_p = 1; 1296 if (deprecated_trace_start_stop_hook) 1297 deprecated_trace_start_stop_hook (1, from_tty); 1298 1299 } 1300 else 1301 error (_("Trace can only be run on remote targets.")); 1302 } 1303 1304 /* Send the definition of a single tracepoint to the target. */ 1305 1306 void 1307 download_tracepoint (struct breakpoint *t) 1308 { 1309 char tmp[40]; 1310 char buf[2048]; 1311 char **tdp_actions; 1312 char **stepping_actions; 1313 int ndx; 1314 struct cleanup *old_chain = NULL; 1315 struct agent_expr *aexpr; 1316 struct cleanup *aexpr_chain = NULL; 1317 1318 sprintf_vma (tmp, (t->loc ? t->loc->address : 0)); 1319 sprintf (buf, "QTDP:%x:%s:%c:%lx:%x", t->number, 1320 tmp, /* address */ 1321 (t->enable_state == bp_enabled ? 'E' : 'D'), 1322 t->step_count, t->pass_count); 1323 /* If the tracepoint has a conditional, make it into an agent 1324 expression and append to the definition. */ 1325 if (t->loc->cond) 1326 { 1327 /* Only test support at download time, we may not know target 1328 capabilities at definition time. */ 1329 if (remote_supports_cond_tracepoints ()) 1330 { 1331 aexpr = gen_eval_for_expr (t->loc->address, t->loc->cond); 1332 aexpr_chain = make_cleanup_free_agent_expr (aexpr); 1333 sprintf (buf + strlen (buf), ":X%x,", aexpr->len); 1334 mem2hex (aexpr->buf, buf + strlen (buf), aexpr->len); 1335 do_cleanups (aexpr_chain); 1336 } 1337 else 1338 warning (_("Target does not support conditional tracepoints, ignoring tp %d cond"), t->number); 1339 } 1340 1341 if (t->actions) 1342 strcat (buf, "-"); 1343 putpkt (buf); 1344 remote_get_noisy_reply (&target_buf, &target_buf_size); 1345 if (strcmp (target_buf, "OK")) 1346 error (_("Target does not support tracepoints.")); 1347 1348 if (!t->actions) 1349 return; 1350 1351 encode_actions (t, &tdp_actions, &stepping_actions); 1352 old_chain = make_cleanup (free_actions_list_cleanup_wrapper, 1353 tdp_actions); 1354 (void) make_cleanup (free_actions_list_cleanup_wrapper, stepping_actions); 1355 1356 /* do_single_steps (t); */ 1357 if (tdp_actions) 1358 { 1359 for (ndx = 0; tdp_actions[ndx]; ndx++) 1360 { 1361 QUIT; /* allow user to bail out with ^C */ 1362 sprintf (buf, "QTDP:-%x:%s:%s%c", 1363 t->number, tmp, /* address */ 1364 tdp_actions[ndx], 1365 ((tdp_actions[ndx + 1] || stepping_actions) 1366 ? '-' : 0)); 1367 putpkt (buf); 1368 remote_get_noisy_reply (&target_buf, 1369 &target_buf_size); 1370 if (strcmp (target_buf, "OK")) 1371 error (_("Error on target while setting tracepoints.")); 1372 } 1373 } 1374 if (stepping_actions) 1375 { 1376 for (ndx = 0; stepping_actions[ndx]; ndx++) 1377 { 1378 QUIT; /* allow user to bail out with ^C */ 1379 sprintf (buf, "QTDP:-%x:%s:%s%s%s", 1380 t->number, tmp, /* address */ 1381 ((ndx == 0) ? "S" : ""), 1382 stepping_actions[ndx], 1383 (stepping_actions[ndx + 1] ? "-" : "")); 1384 putpkt (buf); 1385 remote_get_noisy_reply (&target_buf, 1386 &target_buf_size); 1387 if (strcmp (target_buf, "OK")) 1388 error (_("Error on target while setting tracepoints.")); 1389 } 1390 } 1391 do_cleanups (old_chain); 1392 } 1393 1394 /* tstop command */ 1395 static void 1396 trace_stop_command (char *args, int from_tty) 1397 { 1398 if (target_is_remote ()) 1399 { 1400 putpkt ("QTStop"); 1401 remote_get_noisy_reply (&target_buf, &target_buf_size); 1402 if (strcmp (target_buf, "OK")) 1403 error (_("Bogus reply from target: %s"), target_buf); 1404 trace_running_p = 0; 1405 if (deprecated_trace_start_stop_hook) 1406 deprecated_trace_start_stop_hook (0, from_tty); 1407 } 1408 else 1409 error (_("Trace can only be run on remote targets.")); 1410 } 1411 1412 unsigned long trace_running_p; 1413 1414 /* tstatus command */ 1415 static void 1416 trace_status_command (char *args, int from_tty) 1417 { 1418 if (target_is_remote ()) 1419 { 1420 putpkt ("qTStatus"); 1421 remote_get_noisy_reply (&target_buf, &target_buf_size); 1422 1423 if (target_buf[0] != 'T' || 1424 (target_buf[1] != '0' && target_buf[1] != '1')) 1425 error (_("Bogus reply from target: %s"), target_buf); 1426 1427 /* exported for use by the GUI */ 1428 trace_running_p = (target_buf[1] == '1'); 1429 } 1430 else 1431 error (_("Trace can only be run on remote targets.")); 1432 } 1433 1434 /* Worker function for the various flavors of the tfind command. */ 1435 static void 1436 finish_tfind_command (char **msg, 1437 long *sizeof_msg, 1438 int from_tty) 1439 { 1440 int target_frameno = -1, target_tracept = -1; 1441 struct frame_id old_frame_id; 1442 char *reply; 1443 1444 old_frame_id = get_frame_id (get_current_frame ()); 1445 1446 putpkt (*msg); 1447 reply = remote_get_noisy_reply (msg, sizeof_msg); 1448 1449 while (reply && *reply) 1450 switch (*reply) 1451 { 1452 case 'F': 1453 if ((target_frameno = (int) strtol (++reply, &reply, 16)) == -1) 1454 { 1455 /* A request for a non-existant trace frame has failed. 1456 Our response will be different, depending on FROM_TTY: 1457 1458 If FROM_TTY is true, meaning that this command was 1459 typed interactively by the user, then give an error 1460 and DO NOT change the state of traceframe_number etc. 1461 1462 However if FROM_TTY is false, meaning that we're either 1463 in a script, a loop, or a user-defined command, then 1464 DON'T give an error, but DO change the state of 1465 traceframe_number etc. to invalid. 1466 1467 The rationalle is that if you typed the command, you 1468 might just have committed a typo or something, and you'd 1469 like to NOT lose your current debugging state. However 1470 if you're in a user-defined command or especially in a 1471 loop, then you need a way to detect that the command 1472 failed WITHOUT aborting. This allows you to write 1473 scripts that search thru the trace buffer until the end, 1474 and then continue on to do something else. */ 1475 1476 if (from_tty) 1477 error (_("Target failed to find requested trace frame.")); 1478 else 1479 { 1480 if (info_verbose) 1481 printf_filtered ("End of trace buffer.\n"); 1482 /* The following will not recurse, since it's 1483 special-cased. */ 1484 trace_find_command ("-1", from_tty); 1485 reply = NULL; /* Break out of loop 1486 (avoid recursive nonsense). */ 1487 } 1488 } 1489 break; 1490 case 'T': 1491 if ((target_tracept = (int) strtol (++reply, &reply, 16)) == -1) 1492 error (_("Target failed to find requested trace frame.")); 1493 break; 1494 case 'O': /* "OK"? */ 1495 if (reply[1] == 'K' && reply[2] == '\0') 1496 reply += 2; 1497 else 1498 error (_("Bogus reply from target: %s"), reply); 1499 break; 1500 default: 1501 error (_("Bogus reply from target: %s"), reply); 1502 } 1503 1504 reinit_frame_cache (); 1505 registers_changed (); 1506 set_traceframe_num (target_frameno); 1507 set_tracepoint_num (target_tracept); 1508 if (target_frameno == -1) 1509 set_traceframe_context (NULL); 1510 else 1511 set_traceframe_context (get_current_frame ()); 1512 1513 if (from_tty) 1514 { 1515 enum print_what print_what; 1516 1517 /* NOTE: in immitation of the step command, try to determine 1518 whether we have made a transition from one function to 1519 another. If so, we'll print the "stack frame" (ie. the new 1520 function and it's arguments) -- otherwise we'll just show the 1521 new source line. */ 1522 1523 if (frame_id_eq (old_frame_id, 1524 get_frame_id (get_current_frame ()))) 1525 print_what = SRC_LINE; 1526 else 1527 print_what = SRC_AND_LOC; 1528 1529 print_stack_frame (get_selected_frame (NULL), 1, print_what); 1530 do_displays (); 1531 } 1532 } 1533 1534 /* trace_find_command takes a trace frame number n, 1535 sends "QTFrame:<n>" to the target, 1536 and accepts a reply that may contain several optional pieces 1537 of information: a frame number, a tracepoint number, and an 1538 indication of whether this is a trap frame or a stepping frame. 1539 1540 The minimal response is just "OK" (which indicates that the 1541 target does not give us a frame number or a tracepoint number). 1542 Instead of that, the target may send us a string containing 1543 any combination of: 1544 F<hexnum> (gives the selected frame number) 1545 T<hexnum> (gives the selected tracepoint number) 1546 */ 1547 1548 /* tfind command */ 1549 static void 1550 trace_find_command (char *args, int from_tty) 1551 { /* this should only be called with a numeric argument */ 1552 int frameno = -1; 1553 1554 if (target_is_remote ()) 1555 { 1556 if (deprecated_trace_find_hook) 1557 deprecated_trace_find_hook (args, from_tty); 1558 1559 if (args == 0 || *args == 0) 1560 { /* TFIND with no args means find NEXT trace frame. */ 1561 if (traceframe_number == -1) 1562 frameno = 0; /* "next" is first one */ 1563 else 1564 frameno = traceframe_number + 1; 1565 } 1566 else if (0 == strcmp (args, "-")) 1567 { 1568 if (traceframe_number == -1) 1569 error (_("not debugging trace buffer")); 1570 else if (from_tty && traceframe_number == 0) 1571 error (_("already at start of trace buffer")); 1572 1573 frameno = traceframe_number - 1; 1574 } 1575 else 1576 frameno = parse_and_eval_long (args); 1577 1578 if (frameno < -1) 1579 error (_("invalid input (%d is less than zero)"), frameno); 1580 1581 sprintf (target_buf, "QTFrame:%x", frameno); 1582 finish_tfind_command (&target_buf, &target_buf_size, from_tty); 1583 } 1584 else 1585 error (_("Trace can only be run on remote targets.")); 1586 } 1587 1588 /* tfind end */ 1589 static void 1590 trace_find_end_command (char *args, int from_tty) 1591 { 1592 trace_find_command ("-1", from_tty); 1593 } 1594 1595 /* tfind none */ 1596 static void 1597 trace_find_none_command (char *args, int from_tty) 1598 { 1599 trace_find_command ("-1", from_tty); 1600 } 1601 1602 /* tfind start */ 1603 static void 1604 trace_find_start_command (char *args, int from_tty) 1605 { 1606 trace_find_command ("0", from_tty); 1607 } 1608 1609 /* tfind pc command */ 1610 static void 1611 trace_find_pc_command (char *args, int from_tty) 1612 { 1613 CORE_ADDR pc; 1614 char tmp[40]; 1615 1616 if (target_is_remote ()) 1617 { 1618 if (args == 0 || *args == 0) 1619 pc = regcache_read_pc (get_current_regcache ()); 1620 else 1621 pc = parse_and_eval_address (args); 1622 1623 sprintf_vma (tmp, pc); 1624 sprintf (target_buf, "QTFrame:pc:%s", tmp); 1625 finish_tfind_command (&target_buf, &target_buf_size, from_tty); 1626 } 1627 else 1628 error (_("Trace can only be run on remote targets.")); 1629 } 1630 1631 /* tfind tracepoint command */ 1632 static void 1633 trace_find_tracepoint_command (char *args, int from_tty) 1634 { 1635 int tdp; 1636 1637 if (target_is_remote ()) 1638 { 1639 if (args == 0 || *args == 0) 1640 { 1641 if (tracepoint_number == -1) 1642 error (_("No current tracepoint -- please supply an argument.")); 1643 else 1644 tdp = tracepoint_number; /* default is current TDP */ 1645 } 1646 else 1647 tdp = parse_and_eval_long (args); 1648 1649 sprintf (target_buf, "QTFrame:tdp:%x", tdp); 1650 finish_tfind_command (&target_buf, &target_buf_size, from_tty); 1651 } 1652 else 1653 error (_("Trace can only be run on remote targets.")); 1654 } 1655 1656 /* TFIND LINE command: 1657 1658 This command will take a sourceline for argument, just like BREAK 1659 or TRACE (ie. anything that "decode_line_1" can handle). 1660 1661 With no argument, this command will find the next trace frame 1662 corresponding to a source line OTHER THAN THE CURRENT ONE. */ 1663 1664 static void 1665 trace_find_line_command (char *args, int from_tty) 1666 { 1667 static CORE_ADDR start_pc, end_pc; 1668 struct symtabs_and_lines sals; 1669 struct symtab_and_line sal; 1670 struct cleanup *old_chain; 1671 char startpc_str[40], endpc_str[40]; 1672 1673 if (target_is_remote ()) 1674 { 1675 if (args == 0 || *args == 0) 1676 { 1677 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0); 1678 sals.nelts = 1; 1679 sals.sals = (struct symtab_and_line *) 1680 xmalloc (sizeof (struct symtab_and_line)); 1681 sals.sals[0] = sal; 1682 } 1683 else 1684 { 1685 sals = decode_line_spec (args, 1); 1686 sal = sals.sals[0]; 1687 } 1688 1689 old_chain = make_cleanup (xfree, sals.sals); 1690 if (sal.symtab == 0) 1691 { 1692 struct gdbarch *gdbarch = get_current_arch (); 1693 1694 printf_filtered ("TFIND: No line number information available"); 1695 if (sal.pc != 0) 1696 { 1697 /* This is useful for "info line *0x7f34". If we can't 1698 tell the user about a source line, at least let them 1699 have the symbolic address. */ 1700 printf_filtered (" for address "); 1701 wrap_here (" "); 1702 print_address (gdbarch, sal.pc, gdb_stdout); 1703 printf_filtered (";\n -- will attempt to find by PC. \n"); 1704 } 1705 else 1706 { 1707 printf_filtered (".\n"); 1708 return; /* No line, no PC; what can we do? */ 1709 } 1710 } 1711 else if (sal.line > 0 1712 && find_line_pc_range (sal, &start_pc, &end_pc)) 1713 { 1714 struct gdbarch *gdbarch = get_objfile_arch (sal.symtab->objfile); 1715 1716 if (start_pc == end_pc) 1717 { 1718 printf_filtered ("Line %d of \"%s\"", 1719 sal.line, sal.symtab->filename); 1720 wrap_here (" "); 1721 printf_filtered (" is at address "); 1722 print_address (gdbarch, start_pc, gdb_stdout); 1723 wrap_here (" "); 1724 printf_filtered (" but contains no code.\n"); 1725 sal = find_pc_line (start_pc, 0); 1726 if (sal.line > 0 && 1727 find_line_pc_range (sal, &start_pc, &end_pc) && 1728 start_pc != end_pc) 1729 printf_filtered ("Attempting to find line %d instead.\n", 1730 sal.line); 1731 else 1732 error (_("Cannot find a good line.")); 1733 } 1734 } 1735 else 1736 /* Is there any case in which we get here, and have an address 1737 which the user would want to see? If we have debugging 1738 symbols and no line numbers? */ 1739 error (_("Line number %d is out of range for \"%s\"."), 1740 sal.line, sal.symtab->filename); 1741 1742 sprintf_vma (startpc_str, start_pc); 1743 sprintf_vma (endpc_str, end_pc - 1); 1744 /* Find within range of stated line. */ 1745 if (args && *args) 1746 sprintf (target_buf, "QTFrame:range:%s:%s", 1747 startpc_str, endpc_str); 1748 /* Find OUTSIDE OF range of CURRENT line. */ 1749 else 1750 sprintf (target_buf, "QTFrame:outside:%s:%s", 1751 startpc_str, endpc_str); 1752 finish_tfind_command (&target_buf, &target_buf_size, 1753 from_tty); 1754 do_cleanups (old_chain); 1755 } 1756 else 1757 error (_("Trace can only be run on remote targets.")); 1758 } 1759 1760 /* tfind range command */ 1761 static void 1762 trace_find_range_command (char *args, int from_tty) 1763 { 1764 static CORE_ADDR start, stop; 1765 char start_str[40], stop_str[40]; 1766 char *tmp; 1767 1768 if (target_is_remote ()) 1769 { 1770 if (args == 0 || *args == 0) 1771 { /* XXX FIXME: what should default behavior be? */ 1772 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n"); 1773 return; 1774 } 1775 1776 if (0 != (tmp = strchr (args, ','))) 1777 { 1778 *tmp++ = '\0'; /* terminate start address */ 1779 while (isspace ((int) *tmp)) 1780 tmp++; 1781 start = parse_and_eval_address (args); 1782 stop = parse_and_eval_address (tmp); 1783 } 1784 else 1785 { /* no explicit end address? */ 1786 start = parse_and_eval_address (args); 1787 stop = start + 1; /* ??? */ 1788 } 1789 1790 sprintf_vma (start_str, start); 1791 sprintf_vma (stop_str, stop); 1792 sprintf (target_buf, "QTFrame:range:%s:%s", start_str, stop_str); 1793 finish_tfind_command (&target_buf, &target_buf_size, from_tty); 1794 } 1795 else 1796 error (_("Trace can only be run on remote targets.")); 1797 } 1798 1799 /* tfind outside command */ 1800 static void 1801 trace_find_outside_command (char *args, int from_tty) 1802 { 1803 CORE_ADDR start, stop; 1804 char start_str[40], stop_str[40]; 1805 char *tmp; 1806 1807 if (target_is_remote ()) 1808 { 1809 if (args == 0 || *args == 0) 1810 { /* XXX FIXME: what should default behavior be? */ 1811 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n"); 1812 return; 1813 } 1814 1815 if (0 != (tmp = strchr (args, ','))) 1816 { 1817 *tmp++ = '\0'; /* terminate start address */ 1818 while (isspace ((int) *tmp)) 1819 tmp++; 1820 start = parse_and_eval_address (args); 1821 stop = parse_and_eval_address (tmp); 1822 } 1823 else 1824 { /* no explicit end address? */ 1825 start = parse_and_eval_address (args); 1826 stop = start + 1; /* ??? */ 1827 } 1828 1829 sprintf_vma (start_str, start); 1830 sprintf_vma (stop_str, stop); 1831 sprintf (target_buf, "QTFrame:outside:%s:%s", start_str, stop_str); 1832 finish_tfind_command (&target_buf, &target_buf_size, from_tty); 1833 } 1834 else 1835 error (_("Trace can only be run on remote targets.")); 1836 } 1837 1838 /* info scope command: list the locals for a scope. */ 1839 static void 1840 scope_info (char *args, int from_tty) 1841 { 1842 struct symtabs_and_lines sals; 1843 struct symbol *sym; 1844 struct minimal_symbol *msym; 1845 struct block *block; 1846 char **canonical, *symname, *save_args = args; 1847 struct dict_iterator iter; 1848 int j, count = 0; 1849 struct gdbarch *gdbarch; 1850 int regno; 1851 1852 if (args == 0 || *args == 0) 1853 error (_("requires an argument (function, line or *addr) to define a scope")); 1854 1855 sals = decode_line_1 (&args, 1, NULL, 0, &canonical, NULL); 1856 if (sals.nelts == 0) 1857 return; /* presumably decode_line_1 has already warned */ 1858 1859 /* Resolve line numbers to PC */ 1860 resolve_sal_pc (&sals.sals[0]); 1861 block = block_for_pc (sals.sals[0].pc); 1862 1863 while (block != 0) 1864 { 1865 QUIT; /* allow user to bail out with ^C */ 1866 ALL_BLOCK_SYMBOLS (block, iter, sym) 1867 { 1868 QUIT; /* allow user to bail out with ^C */ 1869 if (count == 0) 1870 printf_filtered ("Scope for %s:\n", save_args); 1871 count++; 1872 1873 symname = SYMBOL_PRINT_NAME (sym); 1874 if (symname == NULL || *symname == '\0') 1875 continue; /* probably botched, certainly useless */ 1876 1877 gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile); 1878 1879 printf_filtered ("Symbol %s is ", symname); 1880 switch (SYMBOL_CLASS (sym)) 1881 { 1882 default: 1883 case LOC_UNDEF: /* messed up symbol? */ 1884 printf_filtered ("a bogus symbol, class %d.\n", 1885 SYMBOL_CLASS (sym)); 1886 count--; /* don't count this one */ 1887 continue; 1888 case LOC_CONST: 1889 printf_filtered ("a constant with value %ld (0x%lx)", 1890 SYMBOL_VALUE (sym), SYMBOL_VALUE (sym)); 1891 break; 1892 case LOC_CONST_BYTES: 1893 printf_filtered ("constant bytes: "); 1894 if (SYMBOL_TYPE (sym)) 1895 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++) 1896 fprintf_filtered (gdb_stdout, " %02x", 1897 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]); 1898 break; 1899 case LOC_STATIC: 1900 printf_filtered ("in static storage at address "); 1901 printf_filtered ("%s", paddress (gdbarch, 1902 SYMBOL_VALUE_ADDRESS (sym))); 1903 break; 1904 case LOC_REGISTER: 1905 /* GDBARCH is the architecture associated with the objfile 1906 the symbol is defined in; the target architecture may be 1907 different, and may provide additional registers. However, 1908 we do not know the target architecture at this point. 1909 We assume the objfile architecture will contain all the 1910 standard registers that occur in debug info in that 1911 objfile. */ 1912 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch); 1913 1914 if (SYMBOL_IS_ARGUMENT (sym)) 1915 printf_filtered ("an argument in register $%s", 1916 gdbarch_register_name (gdbarch, regno)); 1917 else 1918 printf_filtered ("a local variable in register $%s", 1919 gdbarch_register_name (gdbarch, regno)); 1920 break; 1921 case LOC_ARG: 1922 printf_filtered ("an argument at stack/frame offset %ld", 1923 SYMBOL_VALUE (sym)); 1924 break; 1925 case LOC_LOCAL: 1926 printf_filtered ("a local variable at frame offset %ld", 1927 SYMBOL_VALUE (sym)); 1928 break; 1929 case LOC_REF_ARG: 1930 printf_filtered ("a reference argument at offset %ld", 1931 SYMBOL_VALUE (sym)); 1932 break; 1933 case LOC_REGPARM_ADDR: 1934 /* Note comment at LOC_REGISTER. */ 1935 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch); 1936 printf_filtered ("the address of an argument, in register $%s", 1937 gdbarch_register_name (gdbarch, regno)); 1938 break; 1939 case LOC_TYPEDEF: 1940 printf_filtered ("a typedef.\n"); 1941 continue; 1942 case LOC_LABEL: 1943 printf_filtered ("a label at address "); 1944 printf_filtered ("%s", paddress (gdbarch, 1945 SYMBOL_VALUE_ADDRESS (sym))); 1946 break; 1947 case LOC_BLOCK: 1948 printf_filtered ("a function at address "); 1949 printf_filtered ("%s", 1950 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym)))); 1951 break; 1952 case LOC_UNRESOLVED: 1953 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym), 1954 NULL, NULL); 1955 if (msym == NULL) 1956 printf_filtered ("Unresolved Static"); 1957 else 1958 { 1959 printf_filtered ("static storage at address "); 1960 printf_filtered ("%s", 1961 paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msym))); 1962 } 1963 break; 1964 case LOC_OPTIMIZED_OUT: 1965 printf_filtered ("optimized out.\n"); 1966 continue; 1967 case LOC_COMPUTED: 1968 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym, gdb_stdout); 1969 break; 1970 } 1971 if (SYMBOL_TYPE (sym)) 1972 printf_filtered (", length %d.\n", 1973 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)))); 1974 } 1975 if (BLOCK_FUNCTION (block)) 1976 break; 1977 else 1978 block = BLOCK_SUPERBLOCK (block); 1979 } 1980 if (count <= 0) 1981 printf_filtered ("Scope for %s contains no locals or arguments.\n", 1982 save_args); 1983 } 1984 1985 /* worker function (cleanup) */ 1986 static void 1987 replace_comma (void *data) 1988 { 1989 char *comma = data; 1990 *comma = ','; 1991 } 1992 1993 /* tdump command */ 1994 static void 1995 trace_dump_command (char *args, int from_tty) 1996 { 1997 struct regcache *regcache; 1998 struct gdbarch *gdbarch; 1999 struct breakpoint *t; 2000 struct action_line *action; 2001 char *action_exp, *next_comma; 2002 struct cleanup *old_cleanups; 2003 int stepping_actions = 0; 2004 int stepping_frame = 0; 2005 2006 if (!target_is_remote ()) 2007 { 2008 error (_("Trace can only be run on remote targets.")); 2009 return; 2010 } 2011 2012 if (tracepoint_number == -1) 2013 { 2014 warning (_("No current trace frame.")); 2015 return; 2016 } 2017 2018 t = get_tracepoint (tracepoint_number); 2019 2020 if (t == NULL) 2021 error (_("No known tracepoint matches 'current' tracepoint #%d."), 2022 tracepoint_number); 2023 2024 old_cleanups = make_cleanup (null_cleanup, NULL); 2025 2026 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n", 2027 tracepoint_number, traceframe_number); 2028 2029 /* The current frame is a trap frame if the frame PC is equal 2030 to the tracepoint PC. If not, then the current frame was 2031 collected during single-stepping. */ 2032 2033 regcache = get_current_regcache (); 2034 gdbarch = get_regcache_arch (regcache); 2035 2036 stepping_frame = (t->loc->address != (regcache_read_pc (regcache) 2037 - gdbarch_decr_pc_after_break (gdbarch))); 2038 2039 for (action = t->actions; action; action = action->next) 2040 { 2041 struct cmd_list_element *cmd; 2042 2043 QUIT; /* allow user to bail out with ^C */ 2044 action_exp = action->action; 2045 while (isspace ((int) *action_exp)) 2046 action_exp++; 2047 2048 /* The collection actions to be done while stepping are 2049 bracketed by the commands "while-stepping" and "end". */ 2050 2051 if (*action_exp == '#') /* comment line */ 2052 continue; 2053 2054 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1); 2055 if (cmd == 0) 2056 error (_("Bad action list item: %s"), action_exp); 2057 2058 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand)) 2059 stepping_actions = 1; 2060 else if (cmd_cfunc_eq (cmd, end_actions_pseudocommand)) 2061 stepping_actions = 0; 2062 else if (cmd_cfunc_eq (cmd, collect_pseudocommand)) 2063 { 2064 /* Display the collected data. 2065 For the trap frame, display only what was collected at 2066 the trap. Likewise for stepping frames, display only 2067 what was collected while stepping. This means that the 2068 two boolean variables, STEPPING_FRAME and 2069 STEPPING_ACTIONS should be equal. */ 2070 if (stepping_frame == stepping_actions) 2071 { 2072 do 2073 { /* repeat over a comma-separated list */ 2074 QUIT; /* allow user to bail out with ^C */ 2075 if (*action_exp == ',') 2076 action_exp++; 2077 while (isspace ((int) *action_exp)) 2078 action_exp++; 2079 2080 next_comma = strchr (action_exp, ','); 2081 2082 if (0 == strncasecmp (action_exp, "$reg", 4)) 2083 registers_info (NULL, from_tty); 2084 else if (0 == strncasecmp (action_exp, "$loc", 4)) 2085 locals_info (NULL, from_tty); 2086 else if (0 == strncasecmp (action_exp, "$arg", 4)) 2087 args_info (NULL, from_tty); 2088 else 2089 { /* variable */ 2090 if (next_comma) 2091 { 2092 make_cleanup (replace_comma, next_comma); 2093 *next_comma = '\0'; 2094 } 2095 printf_filtered ("%s = ", action_exp); 2096 output_command (action_exp, from_tty); 2097 printf_filtered ("\n"); 2098 } 2099 if (next_comma) 2100 *next_comma = ','; 2101 action_exp = next_comma; 2102 } 2103 while (action_exp && *action_exp == ','); 2104 } 2105 } 2106 } 2107 discard_cleanups (old_cleanups); 2108 } 2109 2110 /* Convert the memory pointed to by mem into hex, placing result in buf. 2111 * Return a pointer to the last char put in buf (null) 2112 * "stolen" from sparc-stub.c 2113 */ 2114 2115 static const char hexchars[] = "0123456789abcdef"; 2116 2117 static char * 2118 mem2hex (gdb_byte *mem, char *buf, int count) 2119 { 2120 gdb_byte ch; 2121 2122 while (count-- > 0) 2123 { 2124 ch = *mem++; 2125 2126 *buf++ = hexchars[ch >> 4]; 2127 *buf++ = hexchars[ch & 0xf]; 2128 } 2129 2130 *buf = 0; 2131 2132 return buf; 2133 } 2134 2135 int 2136 get_traceframe_number (void) 2137 { 2138 return traceframe_number; 2139 } 2140 2141 2142 /* module initialization */ 2143 void 2144 _initialize_tracepoint (void) 2145 { 2146 struct cmd_list_element *c; 2147 2148 traceframe_number = -1; 2149 tracepoint_number = -1; 2150 2151 if (tracepoint_list.list == NULL) 2152 { 2153 tracepoint_list.listsize = 128; 2154 tracepoint_list.list = xmalloc 2155 (tracepoint_list.listsize * sizeof (struct memrange)); 2156 } 2157 if (tracepoint_list.aexpr_list == NULL) 2158 { 2159 tracepoint_list.aexpr_listsize = 128; 2160 tracepoint_list.aexpr_list = xmalloc 2161 (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *)); 2162 } 2163 2164 if (stepping_list.list == NULL) 2165 { 2166 stepping_list.listsize = 128; 2167 stepping_list.list = xmalloc 2168 (stepping_list.listsize * sizeof (struct memrange)); 2169 } 2170 2171 if (stepping_list.aexpr_list == NULL) 2172 { 2173 stepping_list.aexpr_listsize = 128; 2174 stepping_list.aexpr_list = xmalloc 2175 (stepping_list.aexpr_listsize * sizeof (struct agent_expr *)); 2176 } 2177 2178 add_info ("scope", scope_info, 2179 _("List the variables local to a scope")); 2180 2181 add_cmd ("tracepoints", class_trace, NULL, 2182 _("Tracing of program execution without stopping the program."), 2183 &cmdlist); 2184 2185 add_com ("tdump", class_trace, trace_dump_command, 2186 _("Print everything collected at the current tracepoint.")); 2187 2188 add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\ 2189 Select a trace frame;\n\ 2190 No argument means forward by one frame; '-' means backward by one frame."), 2191 &tfindlist, "tfind ", 1, &cmdlist); 2192 2193 add_cmd ("outside", class_trace, trace_find_outside_command, _("\ 2194 Select a trace frame whose PC is outside the given range.\n\ 2195 Usage: tfind outside addr1, addr2"), 2196 &tfindlist); 2197 2198 add_cmd ("range", class_trace, trace_find_range_command, _("\ 2199 Select a trace frame whose PC is in the given range.\n\ 2200 Usage: tfind range addr1,addr2"), 2201 &tfindlist); 2202 2203 add_cmd ("line", class_trace, trace_find_line_command, _("\ 2204 Select a trace frame by source line.\n\ 2205 Argument can be a line number (with optional source file), \n\ 2206 a function name, or '*' followed by an address.\n\ 2207 Default argument is 'the next source line that was traced'."), 2208 &tfindlist); 2209 2210 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\ 2211 Select a trace frame by tracepoint number.\n\ 2212 Default is the tracepoint for the current trace frame."), 2213 &tfindlist); 2214 2215 add_cmd ("pc", class_trace, trace_find_pc_command, _("\ 2216 Select a trace frame by PC.\n\ 2217 Default is the current PC, or the PC of the current trace frame."), 2218 &tfindlist); 2219 2220 add_cmd ("end", class_trace, trace_find_end_command, _("\ 2221 Synonym for 'none'.\n\ 2222 De-select any trace frame and resume 'live' debugging."), 2223 &tfindlist); 2224 2225 add_cmd ("none", class_trace, trace_find_none_command, 2226 _("De-select any trace frame and resume 'live' debugging."), 2227 &tfindlist); 2228 2229 add_cmd ("start", class_trace, trace_find_start_command, 2230 _("Select the first trace frame in the trace buffer."), 2231 &tfindlist); 2232 2233 add_com ("tstatus", class_trace, trace_status_command, 2234 _("Display the status of the current trace data collection.")); 2235 2236 add_com ("tstop", class_trace, trace_stop_command, 2237 _("Stop trace data collection.")); 2238 2239 add_com ("tstart", class_trace, trace_start_command, 2240 _("Start trace data collection.")); 2241 2242 add_com ("end", class_trace, end_actions_pseudocommand, _("\ 2243 Ends a list of commands or actions.\n\ 2244 Several GDB commands allow you to enter a list of commands or actions.\n\ 2245 Entering \"end\" on a line by itself is the normal way to terminate\n\ 2246 such a list.\n\n\ 2247 Note: the \"end\" command cannot be used at the gdb prompt.")); 2248 2249 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\ 2250 Specify single-stepping behavior at a tracepoint.\n\ 2251 Argument is number of instructions to trace in single-step mode\n\ 2252 following the tracepoint. This command is normally followed by\n\ 2253 one or more \"collect\" commands, to specify what to collect\n\ 2254 while single-stepping.\n\n\ 2255 Note: this command can only be used in a tracepoint \"actions\" list.")); 2256 2257 add_com_alias ("ws", "while-stepping", class_alias, 0); 2258 add_com_alias ("stepping", "while-stepping", class_alias, 0); 2259 2260 add_com ("collect", class_trace, collect_pseudocommand, _("\ 2261 Specify one or more data items to be collected at a tracepoint.\n\ 2262 Accepts a comma-separated list of (one or more) expressions. GDB will\n\ 2263 collect all data (variables, registers) referenced by that expression.\n\ 2264 Also accepts the following special arguments:\n\ 2265 $regs -- all registers.\n\ 2266 $args -- all function arguments.\n\ 2267 $locals -- all variables local to the block/function scope.\n\ 2268 Note: this command can only be used in a tracepoint \"actions\" list.")); 2269 2270 add_com ("actions", class_trace, trace_actions_command, _("\ 2271 Specify the actions to be taken at a tracepoint.\n\ 2272 Tracepoint actions may include collecting of specified data, \n\ 2273 single-stepping, or enabling/disabling other tracepoints, \n\ 2274 depending on target's capabilities.")); 2275 2276 target_buf_size = 2048; 2277 target_buf = xmalloc (target_buf_size); 2278 } 2279