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