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