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