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