1 /* Branch trace support for GDB, the GNU debugger. 2 3 Copyright (C) 2013 Free Software Foundation, Inc. 4 5 Contributed by Intel Corp. <markus.t.metzger@intel.com> 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 #include "defs.h" 23 #include "record.h" 24 #include "gdbthread.h" 25 #include "target.h" 26 #include "gdbcmd.h" 27 #include "disasm.h" 28 #include "observer.h" 29 #include "exceptions.h" 30 #include "cli/cli-utils.h" 31 #include "source.h" 32 #include "ui-out.h" 33 #include "symtab.h" 34 #include "filenames.h" 35 36 /* The target_ops of record-btrace. */ 37 static struct target_ops record_btrace_ops; 38 39 /* A new thread observer enabling branch tracing for the new thread. */ 40 static struct observer *record_btrace_thread_observer; 41 42 /* Print a record-btrace debug message. Use do ... while (0) to avoid 43 ambiguities when used in if statements. */ 44 45 #define DEBUG(msg, args...) \ 46 do \ 47 { \ 48 if (record_debug != 0) \ 49 fprintf_unfiltered (gdb_stdlog, \ 50 "[record-btrace] " msg "\n", ##args); \ 51 } \ 52 while (0) 53 54 55 /* Update the branch trace for the current thread and return a pointer to its 56 branch trace information struct. 57 58 Throws an error if there is no thread or no trace. This function never 59 returns NULL. */ 60 61 static struct btrace_thread_info * 62 require_btrace (void) 63 { 64 struct thread_info *tp; 65 struct btrace_thread_info *btinfo; 66 67 DEBUG ("require"); 68 69 tp = find_thread_ptid (inferior_ptid); 70 if (tp == NULL) 71 error (_("No thread.")); 72 73 btrace_fetch (tp); 74 75 btinfo = &tp->btrace; 76 77 if (VEC_empty (btrace_inst_s, btinfo->itrace)) 78 error (_("No trace.")); 79 80 return btinfo; 81 } 82 83 /* Enable branch tracing for one thread. Warn on errors. */ 84 85 static void 86 record_btrace_enable_warn (struct thread_info *tp) 87 { 88 volatile struct gdb_exception error; 89 90 TRY_CATCH (error, RETURN_MASK_ERROR) 91 btrace_enable (tp); 92 93 if (error.message != NULL) 94 warning ("%s", error.message); 95 } 96 97 /* Callback function to disable branch tracing for one thread. */ 98 99 static void 100 record_btrace_disable_callback (void *arg) 101 { 102 struct thread_info *tp; 103 104 tp = arg; 105 106 btrace_disable (tp); 107 } 108 109 /* Enable automatic tracing of new threads. */ 110 111 static void 112 record_btrace_auto_enable (void) 113 { 114 DEBUG ("attach thread observer"); 115 116 record_btrace_thread_observer 117 = observer_attach_new_thread (record_btrace_enable_warn); 118 } 119 120 /* Disable automatic tracing of new threads. */ 121 122 static void 123 record_btrace_auto_disable (void) 124 { 125 /* The observer may have been detached, already. */ 126 if (record_btrace_thread_observer == NULL) 127 return; 128 129 DEBUG ("detach thread observer"); 130 131 observer_detach_new_thread (record_btrace_thread_observer); 132 record_btrace_thread_observer = NULL; 133 } 134 135 /* The to_open method of target record-btrace. */ 136 137 static void 138 record_btrace_open (char *args, int from_tty) 139 { 140 struct cleanup *disable_chain; 141 struct thread_info *tp; 142 143 DEBUG ("open"); 144 145 if (RECORD_IS_USED) 146 error (_("The process is already being recorded.")); 147 148 if (!target_has_execution) 149 error (_("The program is not being run.")); 150 151 if (!target_supports_btrace ()) 152 error (_("Target does not support branch tracing.")); 153 154 gdb_assert (record_btrace_thread_observer == NULL); 155 156 disable_chain = make_cleanup (null_cleanup, NULL); 157 ALL_THREADS (tp) 158 if (args == NULL || *args == 0 || number_is_in_list (args, tp->num)) 159 { 160 btrace_enable (tp); 161 162 make_cleanup (record_btrace_disable_callback, tp); 163 } 164 165 record_btrace_auto_enable (); 166 167 push_target (&record_btrace_ops); 168 169 observer_notify_record_changed (current_inferior (), 1); 170 171 discard_cleanups (disable_chain); 172 } 173 174 /* The to_stop_recording method of target record-btrace. */ 175 176 static void 177 record_btrace_stop_recording (void) 178 { 179 struct thread_info *tp; 180 181 DEBUG ("stop recording"); 182 183 record_btrace_auto_disable (); 184 185 ALL_THREADS (tp) 186 if (tp->btrace.target != NULL) 187 btrace_disable (tp); 188 } 189 190 /* The to_close method of target record-btrace. */ 191 192 static void 193 record_btrace_close (int quitting) 194 { 195 /* Make sure automatic recording gets disabled even if we did not stop 196 recording before closing the record-btrace target. */ 197 record_btrace_auto_disable (); 198 199 /* We already stopped recording. */ 200 } 201 202 /* The to_info_record method of target record-btrace. */ 203 204 static void 205 record_btrace_info (void) 206 { 207 struct btrace_thread_info *btinfo; 208 struct thread_info *tp; 209 unsigned int insts, funcs; 210 211 DEBUG ("info"); 212 213 tp = find_thread_ptid (inferior_ptid); 214 if (tp == NULL) 215 error (_("No thread.")); 216 217 btrace_fetch (tp); 218 219 btinfo = &tp->btrace; 220 insts = VEC_length (btrace_inst_s, btinfo->itrace); 221 funcs = VEC_length (btrace_func_s, btinfo->ftrace); 222 223 printf_unfiltered (_("Recorded %u instructions in %u functions for thread " 224 "%d (%s).\n"), insts, funcs, tp->num, 225 target_pid_to_str (tp->ptid)); 226 } 227 228 /* Print an unsigned int. */ 229 230 static void 231 ui_out_field_uint (struct ui_out *uiout, const char *fld, unsigned int val) 232 { 233 ui_out_field_fmt (uiout, fld, "%u", val); 234 } 235 236 /* Disassemble a section of the recorded instruction trace. */ 237 238 static void 239 btrace_insn_history (struct btrace_thread_info *btinfo, struct ui_out *uiout, 240 unsigned int begin, unsigned int end, int flags) 241 { 242 struct gdbarch *gdbarch; 243 struct btrace_inst *inst; 244 unsigned int idx; 245 246 DEBUG ("itrace (0x%x): [%u; %u[", flags, begin, end); 247 248 gdbarch = target_gdbarch (); 249 250 for (idx = begin; VEC_iterate (btrace_inst_s, btinfo->itrace, idx, inst) 251 && idx < end; ++idx) 252 { 253 /* Print the instruction index. */ 254 ui_out_field_uint (uiout, "index", idx); 255 ui_out_text (uiout, "\t"); 256 257 /* Disassembly with '/m' flag may not produce the expected result. 258 See PR gdb/11833. */ 259 gdb_disassembly (gdbarch, uiout, NULL, flags, 1, inst->pc, inst->pc + 1); 260 } 261 } 262 263 /* The to_insn_history method of target record-btrace. */ 264 265 static void 266 record_btrace_insn_history (int size, int flags) 267 { 268 struct btrace_thread_info *btinfo; 269 struct cleanup *uiout_cleanup; 270 struct ui_out *uiout; 271 unsigned int context, last, begin, end; 272 273 uiout = current_uiout; 274 uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, 275 "insn history"); 276 btinfo = require_btrace (); 277 last = VEC_length (btrace_inst_s, btinfo->itrace); 278 279 context = abs (size); 280 begin = btinfo->insn_iterator.begin; 281 end = btinfo->insn_iterator.end; 282 283 DEBUG ("insn-history (0x%x): %d, prev: [%u; %u[", flags, size, begin, end); 284 285 if (context == 0) 286 error (_("Bad record instruction-history-size.")); 287 288 /* We start at the end. */ 289 if (end < begin) 290 { 291 /* Truncate the context, if necessary. */ 292 context = min (context, last); 293 294 end = last; 295 begin = end - context; 296 } 297 else if (size < 0) 298 { 299 if (begin == 0) 300 { 301 printf_unfiltered (_("At the start of the branch trace record.\n")); 302 303 btinfo->insn_iterator.end = 0; 304 return; 305 } 306 307 /* Truncate the context, if necessary. */ 308 context = min (context, begin); 309 310 end = begin; 311 begin -= context; 312 } 313 else 314 { 315 if (end == last) 316 { 317 printf_unfiltered (_("At the end of the branch trace record.\n")); 318 319 btinfo->insn_iterator.begin = last; 320 return; 321 } 322 323 /* Truncate the context, if necessary. */ 324 context = min (context, last - end); 325 326 begin = end; 327 end += context; 328 } 329 330 btrace_insn_history (btinfo, uiout, begin, end, flags); 331 332 btinfo->insn_iterator.begin = begin; 333 btinfo->insn_iterator.end = end; 334 335 do_cleanups (uiout_cleanup); 336 } 337 338 /* The to_insn_history_range method of target record-btrace. */ 339 340 static void 341 record_btrace_insn_history_range (ULONGEST from, ULONGEST to, int flags) 342 { 343 struct btrace_thread_info *btinfo; 344 struct cleanup *uiout_cleanup; 345 struct ui_out *uiout; 346 unsigned int last, begin, end; 347 348 uiout = current_uiout; 349 uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, 350 "insn history"); 351 btinfo = require_btrace (); 352 last = VEC_length (btrace_inst_s, btinfo->itrace); 353 354 begin = (unsigned int) from; 355 end = (unsigned int) to; 356 357 DEBUG ("insn-history (0x%x): [%u; %u[", flags, begin, end); 358 359 /* Check for wrap-arounds. */ 360 if (begin != from || end != to) 361 error (_("Bad range.")); 362 363 if (end <= begin) 364 error (_("Bad range.")); 365 366 if (last <= begin) 367 error (_("Range out of bounds.")); 368 369 /* Truncate the range, if necessary. */ 370 if (last < end) 371 end = last; 372 373 btrace_insn_history (btinfo, uiout, begin, end, flags); 374 375 btinfo->insn_iterator.begin = begin; 376 btinfo->insn_iterator.end = end; 377 378 do_cleanups (uiout_cleanup); 379 } 380 381 /* The to_insn_history_from method of target record-btrace. */ 382 383 static void 384 record_btrace_insn_history_from (ULONGEST from, int size, int flags) 385 { 386 ULONGEST begin, end, context; 387 388 context = abs (size); 389 390 if (size < 0) 391 { 392 end = from; 393 394 if (from < context) 395 begin = 0; 396 else 397 begin = from - context; 398 } 399 else 400 { 401 begin = from; 402 end = from + context; 403 404 /* Check for wrap-around. */ 405 if (end < begin) 406 end = ULONGEST_MAX; 407 } 408 409 record_btrace_insn_history_range (begin, end, flags); 410 } 411 412 /* Print the instruction number range for a function call history line. */ 413 414 static void 415 btrace_func_history_insn_range (struct ui_out *uiout, struct btrace_func *bfun) 416 { 417 ui_out_field_uint (uiout, "insn begin", bfun->ibegin); 418 419 if (bfun->ibegin == bfun->iend) 420 return; 421 422 ui_out_text (uiout, "-"); 423 ui_out_field_uint (uiout, "insn end", bfun->iend); 424 } 425 426 /* Print the source line information for a function call history line. */ 427 428 static void 429 btrace_func_history_src_line (struct ui_out *uiout, struct btrace_func *bfun) 430 { 431 struct symbol *sym; 432 433 sym = bfun->sym; 434 if (sym == NULL) 435 return; 436 437 ui_out_field_string (uiout, "file", 438 symtab_to_filename_for_display (sym->symtab)); 439 440 if (bfun->lend == 0) 441 return; 442 443 ui_out_text (uiout, ":"); 444 ui_out_field_int (uiout, "min line", bfun->lbegin); 445 446 if (bfun->lend == bfun->lbegin) 447 return; 448 449 ui_out_text (uiout, "-"); 450 ui_out_field_int (uiout, "max line", bfun->lend); 451 } 452 453 /* Disassemble a section of the recorded function trace. */ 454 455 static void 456 btrace_func_history (struct btrace_thread_info *btinfo, struct ui_out *uiout, 457 unsigned int begin, unsigned int end, 458 enum record_print_flag flags) 459 { 460 struct btrace_func *bfun; 461 unsigned int idx; 462 463 DEBUG ("ftrace (0x%x): [%u; %u[", flags, begin, end); 464 465 for (idx = begin; VEC_iterate (btrace_func_s, btinfo->ftrace, idx, bfun) 466 && idx < end; ++idx) 467 { 468 /* Print the function index. */ 469 ui_out_field_uint (uiout, "index", idx); 470 ui_out_text (uiout, "\t"); 471 472 if ((flags & record_print_insn_range) != 0) 473 { 474 btrace_func_history_insn_range (uiout, bfun); 475 ui_out_text (uiout, "\t"); 476 } 477 478 if ((flags & record_print_src_line) != 0) 479 { 480 btrace_func_history_src_line (uiout, bfun); 481 ui_out_text (uiout, "\t"); 482 } 483 484 if (bfun->sym != NULL) 485 ui_out_field_string (uiout, "function", SYMBOL_PRINT_NAME (bfun->sym)); 486 else if (bfun->msym != NULL) 487 ui_out_field_string (uiout, "function", SYMBOL_PRINT_NAME (bfun->msym)); 488 ui_out_text (uiout, "\n"); 489 } 490 } 491 492 /* The to_call_history method of target record-btrace. */ 493 494 static void 495 record_btrace_call_history (int size, int flags) 496 { 497 struct btrace_thread_info *btinfo; 498 struct cleanup *uiout_cleanup; 499 struct ui_out *uiout; 500 unsigned int context, last, begin, end; 501 502 uiout = current_uiout; 503 uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, 504 "insn history"); 505 btinfo = require_btrace (); 506 last = VEC_length (btrace_func_s, btinfo->ftrace); 507 508 context = abs (size); 509 begin = btinfo->func_iterator.begin; 510 end = btinfo->func_iterator.end; 511 512 DEBUG ("func-history (0x%x): %d, prev: [%u; %u[", flags, size, begin, end); 513 514 if (context == 0) 515 error (_("Bad record function-call-history-size.")); 516 517 /* We start at the end. */ 518 if (end < begin) 519 { 520 /* Truncate the context, if necessary. */ 521 context = min (context, last); 522 523 end = last; 524 begin = end - context; 525 } 526 else if (size < 0) 527 { 528 if (begin == 0) 529 { 530 printf_unfiltered (_("At the start of the branch trace record.\n")); 531 532 btinfo->func_iterator.end = 0; 533 return; 534 } 535 536 /* Truncate the context, if necessary. */ 537 context = min (context, begin); 538 539 end = begin; 540 begin -= context; 541 } 542 else 543 { 544 if (end == last) 545 { 546 printf_unfiltered (_("At the end of the branch trace record.\n")); 547 548 btinfo->func_iterator.begin = last; 549 return; 550 } 551 552 /* Truncate the context, if necessary. */ 553 context = min (context, last - end); 554 555 begin = end; 556 end += context; 557 } 558 559 btrace_func_history (btinfo, uiout, begin, end, flags); 560 561 btinfo->func_iterator.begin = begin; 562 btinfo->func_iterator.end = end; 563 564 do_cleanups (uiout_cleanup); 565 } 566 567 /* The to_call_history_range method of target record-btrace. */ 568 569 static void 570 record_btrace_call_history_range (ULONGEST from, ULONGEST to, int flags) 571 { 572 struct btrace_thread_info *btinfo; 573 struct cleanup *uiout_cleanup; 574 struct ui_out *uiout; 575 unsigned int last, begin, end; 576 577 uiout = current_uiout; 578 uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, 579 "func history"); 580 btinfo = require_btrace (); 581 last = VEC_length (btrace_func_s, btinfo->ftrace); 582 583 begin = (unsigned int) from; 584 end = (unsigned int) to; 585 586 DEBUG ("func-history (0x%x): [%u; %u[", flags, begin, end); 587 588 /* Check for wrap-arounds. */ 589 if (begin != from || end != to) 590 error (_("Bad range.")); 591 592 if (end <= begin) 593 error (_("Bad range.")); 594 595 if (last <= begin) 596 error (_("Range out of bounds.")); 597 598 /* Truncate the range, if necessary. */ 599 if (last < end) 600 end = last; 601 602 btrace_func_history (btinfo, uiout, begin, end, flags); 603 604 btinfo->func_iterator.begin = begin; 605 btinfo->func_iterator.end = end; 606 607 do_cleanups (uiout_cleanup); 608 } 609 610 /* The to_call_history_from method of target record-btrace. */ 611 612 static void 613 record_btrace_call_history_from (ULONGEST from, int size, int flags) 614 { 615 ULONGEST begin, end, context; 616 617 context = abs (size); 618 619 if (size < 0) 620 { 621 end = from; 622 623 if (from < context) 624 begin = 0; 625 else 626 begin = from - context; 627 } 628 else 629 { 630 begin = from; 631 end = from + context; 632 633 /* Check for wrap-around. */ 634 if (end < begin) 635 end = ULONGEST_MAX; 636 } 637 638 record_btrace_call_history_range (begin, end, flags); 639 } 640 641 /* Initialize the record-btrace target ops. */ 642 643 static void 644 init_record_btrace_ops (void) 645 { 646 struct target_ops *ops; 647 648 ops = &record_btrace_ops; 649 ops->to_shortname = "record-btrace"; 650 ops->to_longname = "Branch tracing target"; 651 ops->to_doc = "Collect control-flow trace and provide the execution history."; 652 ops->to_open = record_btrace_open; 653 ops->to_close = record_btrace_close; 654 ops->to_detach = record_detach; 655 ops->to_disconnect = record_disconnect; 656 ops->to_mourn_inferior = record_mourn_inferior; 657 ops->to_kill = record_kill; 658 ops->to_create_inferior = find_default_create_inferior; 659 ops->to_stop_recording = record_btrace_stop_recording; 660 ops->to_info_record = record_btrace_info; 661 ops->to_insn_history = record_btrace_insn_history; 662 ops->to_insn_history_from = record_btrace_insn_history_from; 663 ops->to_insn_history_range = record_btrace_insn_history_range; 664 ops->to_call_history = record_btrace_call_history; 665 ops->to_call_history_from = record_btrace_call_history_from; 666 ops->to_call_history_range = record_btrace_call_history_range; 667 ops->to_stratum = record_stratum; 668 ops->to_magic = OPS_MAGIC; 669 } 670 671 /* Alias for "target record". */ 672 673 static void 674 cmd_record_btrace_start (char *args, int from_tty) 675 { 676 if (args != NULL && *args != 0) 677 error (_("Invalid argument.")); 678 679 execute_command ("target record-btrace", from_tty); 680 } 681 682 void _initialize_record_btrace (void); 683 684 /* Initialize btrace commands. */ 685 686 void 687 _initialize_record_btrace (void) 688 { 689 add_cmd ("btrace", class_obscure, cmd_record_btrace_start, 690 _("Start branch trace recording."), 691 &record_cmdlist); 692 add_alias_cmd ("b", "btrace", class_obscure, 1, &record_cmdlist); 693 694 init_record_btrace_ops (); 695 add_target (&record_btrace_ops); 696 } 697