1 /* Target-struct-independent code to start (run) and stop an inferior 2 process. 3 4 Copyright (C) 1986-2012 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 "gdb_string.h" 23 #include <ctype.h> 24 #include "symtab.h" 25 #include "frame.h" 26 #include "inferior.h" 27 #include "exceptions.h" 28 #include "breakpoint.h" 29 #include "gdb_wait.h" 30 #include "gdbcore.h" 31 #include "gdbcmd.h" 32 #include "cli/cli-script.h" 33 #include "target.h" 34 #include "gdbthread.h" 35 #include "annotate.h" 36 #include "symfile.h" 37 #include "top.h" 38 #include <signal.h> 39 #include "inf-loop.h" 40 #include "regcache.h" 41 #include "value.h" 42 #include "observer.h" 43 #include "language.h" 44 #include "solib.h" 45 #include "main.h" 46 #include "dictionary.h" 47 #include "block.h" 48 #include "gdb_assert.h" 49 #include "mi/mi-common.h" 50 #include "event-top.h" 51 #include "record.h" 52 #include "inline-frame.h" 53 #include "jit.h" 54 #include "tracepoint.h" 55 #include "continuations.h" 56 #include "interps.h" 57 #include "skip.h" 58 59 /* Prototypes for local functions */ 60 61 static void signals_info (char *, int); 62 63 static void handle_command (char *, int); 64 65 static void sig_print_info (enum target_signal); 66 67 static void sig_print_header (void); 68 69 static void resume_cleanups (void *); 70 71 static int hook_stop_stub (void *); 72 73 static int restore_selected_frame (void *); 74 75 static int follow_fork (void); 76 77 static void set_schedlock_func (char *args, int from_tty, 78 struct cmd_list_element *c); 79 80 static int currently_stepping (struct thread_info *tp); 81 82 static int currently_stepping_or_nexting_callback (struct thread_info *tp, 83 void *data); 84 85 static void xdb_handle_command (char *args, int from_tty); 86 87 static int prepare_to_proceed (int); 88 89 static void print_exited_reason (int exitstatus); 90 91 static void print_signal_exited_reason (enum target_signal siggnal); 92 93 static void print_no_history_reason (void); 94 95 static void print_signal_received_reason (enum target_signal siggnal); 96 97 static void print_end_stepping_range_reason (void); 98 99 void _initialize_infrun (void); 100 101 void nullify_last_target_wait_ptid (void); 102 103 static void insert_hp_step_resume_breakpoint_at_frame (struct frame_info *); 104 105 static void insert_step_resume_breakpoint_at_caller (struct frame_info *); 106 107 static void insert_longjmp_resume_breakpoint (struct gdbarch *, CORE_ADDR); 108 109 /* When set, stop the 'step' command if we enter a function which has 110 no line number information. The normal behavior is that we step 111 over such function. */ 112 int step_stop_if_no_debug = 0; 113 static void 114 show_step_stop_if_no_debug (struct ui_file *file, int from_tty, 115 struct cmd_list_element *c, const char *value) 116 { 117 fprintf_filtered (file, _("Mode of the step operation is %s.\n"), value); 118 } 119 120 /* In asynchronous mode, but simulating synchronous execution. */ 121 122 int sync_execution = 0; 123 124 /* wait_for_inferior and normal_stop use this to notify the user 125 when the inferior stopped in a different thread than it had been 126 running in. */ 127 128 static ptid_t previous_inferior_ptid; 129 130 /* Default behavior is to detach newly forked processes (legacy). */ 131 int detach_fork = 1; 132 133 int debug_displaced = 0; 134 static void 135 show_debug_displaced (struct ui_file *file, int from_tty, 136 struct cmd_list_element *c, const char *value) 137 { 138 fprintf_filtered (file, _("Displace stepping debugging is %s.\n"), value); 139 } 140 141 int debug_infrun = 0; 142 static void 143 show_debug_infrun (struct ui_file *file, int from_tty, 144 struct cmd_list_element *c, const char *value) 145 { 146 fprintf_filtered (file, _("Inferior debugging is %s.\n"), value); 147 } 148 149 150 /* Support for disabling address space randomization. */ 151 152 int disable_randomization = 1; 153 154 static void 155 show_disable_randomization (struct ui_file *file, int from_tty, 156 struct cmd_list_element *c, const char *value) 157 { 158 if (target_supports_disable_randomization ()) 159 fprintf_filtered (file, 160 _("Disabling randomization of debuggee's " 161 "virtual address space is %s.\n"), 162 value); 163 else 164 fputs_filtered (_("Disabling randomization of debuggee's " 165 "virtual address space is unsupported on\n" 166 "this platform.\n"), file); 167 } 168 169 static void 170 set_disable_randomization (char *args, int from_tty, 171 struct cmd_list_element *c) 172 { 173 if (!target_supports_disable_randomization ()) 174 error (_("Disabling randomization of debuggee's " 175 "virtual address space is unsupported on\n" 176 "this platform.")); 177 } 178 179 180 /* If the program uses ELF-style shared libraries, then calls to 181 functions in shared libraries go through stubs, which live in a 182 table called the PLT (Procedure Linkage Table). The first time the 183 function is called, the stub sends control to the dynamic linker, 184 which looks up the function's real address, patches the stub so 185 that future calls will go directly to the function, and then passes 186 control to the function. 187 188 If we are stepping at the source level, we don't want to see any of 189 this --- we just want to skip over the stub and the dynamic linker. 190 The simple approach is to single-step until control leaves the 191 dynamic linker. 192 193 However, on some systems (e.g., Red Hat's 5.2 distribution) the 194 dynamic linker calls functions in the shared C library, so you 195 can't tell from the PC alone whether the dynamic linker is still 196 running. In this case, we use a step-resume breakpoint to get us 197 past the dynamic linker, as if we were using "next" to step over a 198 function call. 199 200 in_solib_dynsym_resolve_code() says whether we're in the dynamic 201 linker code or not. Normally, this means we single-step. However, 202 if SKIP_SOLIB_RESOLVER then returns non-zero, then its value is an 203 address where we can place a step-resume breakpoint to get past the 204 linker's symbol resolution function. 205 206 in_solib_dynsym_resolve_code() can generally be implemented in a 207 pretty portable way, by comparing the PC against the address ranges 208 of the dynamic linker's sections. 209 210 SKIP_SOLIB_RESOLVER is generally going to be system-specific, since 211 it depends on internal details of the dynamic linker. It's usually 212 not too hard to figure out where to put a breakpoint, but it 213 certainly isn't portable. SKIP_SOLIB_RESOLVER should do plenty of 214 sanity checking. If it can't figure things out, returning zero and 215 getting the (possibly confusing) stepping behavior is better than 216 signalling an error, which will obscure the change in the 217 inferior's state. */ 218 219 /* This function returns TRUE if pc is the address of an instruction 220 that lies within the dynamic linker (such as the event hook, or the 221 dld itself). 222 223 This function must be used only when a dynamic linker event has 224 been caught, and the inferior is being stepped out of the hook, or 225 undefined results are guaranteed. */ 226 227 #ifndef SOLIB_IN_DYNAMIC_LINKER 228 #define SOLIB_IN_DYNAMIC_LINKER(pid,pc) 0 229 #endif 230 231 /* "Observer mode" is somewhat like a more extreme version of 232 non-stop, in which all GDB operations that might affect the 233 target's execution have been disabled. */ 234 235 static int non_stop_1 = 0; 236 237 int observer_mode = 0; 238 static int observer_mode_1 = 0; 239 240 static void 241 set_observer_mode (char *args, int from_tty, 242 struct cmd_list_element *c) 243 { 244 extern int pagination_enabled; 245 246 if (target_has_execution) 247 { 248 observer_mode_1 = observer_mode; 249 error (_("Cannot change this setting while the inferior is running.")); 250 } 251 252 observer_mode = observer_mode_1; 253 254 may_write_registers = !observer_mode; 255 may_write_memory = !observer_mode; 256 may_insert_breakpoints = !observer_mode; 257 may_insert_tracepoints = !observer_mode; 258 /* We can insert fast tracepoints in or out of observer mode, 259 but enable them if we're going into this mode. */ 260 if (observer_mode) 261 may_insert_fast_tracepoints = 1; 262 may_stop = !observer_mode; 263 update_target_permissions (); 264 265 /* Going *into* observer mode we must force non-stop, then 266 going out we leave it that way. */ 267 if (observer_mode) 268 { 269 target_async_permitted = 1; 270 pagination_enabled = 0; 271 non_stop = non_stop_1 = 1; 272 } 273 274 if (from_tty) 275 printf_filtered (_("Observer mode is now %s.\n"), 276 (observer_mode ? "on" : "off")); 277 } 278 279 static void 280 show_observer_mode (struct ui_file *file, int from_tty, 281 struct cmd_list_element *c, const char *value) 282 { 283 fprintf_filtered (file, _("Observer mode is %s.\n"), value); 284 } 285 286 /* This updates the value of observer mode based on changes in 287 permissions. Note that we are deliberately ignoring the values of 288 may-write-registers and may-write-memory, since the user may have 289 reason to enable these during a session, for instance to turn on a 290 debugging-related global. */ 291 292 void 293 update_observer_mode (void) 294 { 295 int newval; 296 297 newval = (!may_insert_breakpoints 298 && !may_insert_tracepoints 299 && may_insert_fast_tracepoints 300 && !may_stop 301 && non_stop); 302 303 /* Let the user know if things change. */ 304 if (newval != observer_mode) 305 printf_filtered (_("Observer mode is now %s.\n"), 306 (newval ? "on" : "off")); 307 308 observer_mode = observer_mode_1 = newval; 309 } 310 311 /* Tables of how to react to signals; the user sets them. */ 312 313 static unsigned char *signal_stop; 314 static unsigned char *signal_print; 315 static unsigned char *signal_program; 316 317 /* Table of signals that the target may silently handle. 318 This is automatically determined from the flags above, 319 and simply cached here. */ 320 static unsigned char *signal_pass; 321 322 #define SET_SIGS(nsigs,sigs,flags) \ 323 do { \ 324 int signum = (nsigs); \ 325 while (signum-- > 0) \ 326 if ((sigs)[signum]) \ 327 (flags)[signum] = 1; \ 328 } while (0) 329 330 #define UNSET_SIGS(nsigs,sigs,flags) \ 331 do { \ 332 int signum = (nsigs); \ 333 while (signum-- > 0) \ 334 if ((sigs)[signum]) \ 335 (flags)[signum] = 0; \ 336 } while (0) 337 338 /* Value to pass to target_resume() to cause all threads to resume. */ 339 340 #define RESUME_ALL minus_one_ptid 341 342 /* Command list pointer for the "stop" placeholder. */ 343 344 static struct cmd_list_element *stop_command; 345 346 /* Function inferior was in as of last step command. */ 347 348 static struct symbol *step_start_function; 349 350 /* Nonzero if we want to give control to the user when we're notified 351 of shared library events by the dynamic linker. */ 352 int stop_on_solib_events; 353 static void 354 show_stop_on_solib_events (struct ui_file *file, int from_tty, 355 struct cmd_list_element *c, const char *value) 356 { 357 fprintf_filtered (file, _("Stopping for shared library events is %s.\n"), 358 value); 359 } 360 361 /* Nonzero means expecting a trace trap 362 and should stop the inferior and return silently when it happens. */ 363 364 int stop_after_trap; 365 366 /* Save register contents here when executing a "finish" command or are 367 about to pop a stack dummy frame, if-and-only-if proceed_to_finish is set. 368 Thus this contains the return value from the called function (assuming 369 values are returned in a register). */ 370 371 struct regcache *stop_registers; 372 373 /* Nonzero after stop if current stack frame should be printed. */ 374 375 static int stop_print_frame; 376 377 /* This is a cached copy of the pid/waitstatus of the last event 378 returned by target_wait()/deprecated_target_wait_hook(). This 379 information is returned by get_last_target_status(). */ 380 static ptid_t target_last_wait_ptid; 381 static struct target_waitstatus target_last_waitstatus; 382 383 static void context_switch (ptid_t ptid); 384 385 void init_thread_stepping_state (struct thread_info *tss); 386 387 void init_infwait_state (void); 388 389 static const char follow_fork_mode_child[] = "child"; 390 static const char follow_fork_mode_parent[] = "parent"; 391 392 static const char *follow_fork_mode_kind_names[] = { 393 follow_fork_mode_child, 394 follow_fork_mode_parent, 395 NULL 396 }; 397 398 static const char *follow_fork_mode_string = follow_fork_mode_parent; 399 static void 400 show_follow_fork_mode_string (struct ui_file *file, int from_tty, 401 struct cmd_list_element *c, const char *value) 402 { 403 fprintf_filtered (file, 404 _("Debugger response to a program " 405 "call of fork or vfork is \"%s\".\n"), 406 value); 407 } 408 409 410 /* Tell the target to follow the fork we're stopped at. Returns true 411 if the inferior should be resumed; false, if the target for some 412 reason decided it's best not to resume. */ 413 414 static int 415 follow_fork (void) 416 { 417 int follow_child = (follow_fork_mode_string == follow_fork_mode_child); 418 int should_resume = 1; 419 struct thread_info *tp; 420 421 /* Copy user stepping state to the new inferior thread. FIXME: the 422 followed fork child thread should have a copy of most of the 423 parent thread structure's run control related fields, not just these. 424 Initialized to avoid "may be used uninitialized" warnings from gcc. */ 425 struct breakpoint *step_resume_breakpoint = NULL; 426 struct breakpoint *exception_resume_breakpoint = NULL; 427 CORE_ADDR step_range_start = 0; 428 CORE_ADDR step_range_end = 0; 429 struct frame_id step_frame_id = { 0 }; 430 431 if (!non_stop) 432 { 433 ptid_t wait_ptid; 434 struct target_waitstatus wait_status; 435 436 /* Get the last target status returned by target_wait(). */ 437 get_last_target_status (&wait_ptid, &wait_status); 438 439 /* If not stopped at a fork event, then there's nothing else to 440 do. */ 441 if (wait_status.kind != TARGET_WAITKIND_FORKED 442 && wait_status.kind != TARGET_WAITKIND_VFORKED) 443 return 1; 444 445 /* Check if we switched over from WAIT_PTID, since the event was 446 reported. */ 447 if (!ptid_equal (wait_ptid, minus_one_ptid) 448 && !ptid_equal (inferior_ptid, wait_ptid)) 449 { 450 /* We did. Switch back to WAIT_PTID thread, to tell the 451 target to follow it (in either direction). We'll 452 afterwards refuse to resume, and inform the user what 453 happened. */ 454 switch_to_thread (wait_ptid); 455 should_resume = 0; 456 } 457 } 458 459 tp = inferior_thread (); 460 461 /* If there were any forks/vforks that were caught and are now to be 462 followed, then do so now. */ 463 switch (tp->pending_follow.kind) 464 { 465 case TARGET_WAITKIND_FORKED: 466 case TARGET_WAITKIND_VFORKED: 467 { 468 ptid_t parent, child; 469 470 /* If the user did a next/step, etc, over a fork call, 471 preserve the stepping state in the fork child. */ 472 if (follow_child && should_resume) 473 { 474 step_resume_breakpoint = clone_momentary_breakpoint 475 (tp->control.step_resume_breakpoint); 476 step_range_start = tp->control.step_range_start; 477 step_range_end = tp->control.step_range_end; 478 step_frame_id = tp->control.step_frame_id; 479 exception_resume_breakpoint 480 = clone_momentary_breakpoint (tp->control.exception_resume_breakpoint); 481 482 /* For now, delete the parent's sr breakpoint, otherwise, 483 parent/child sr breakpoints are considered duplicates, 484 and the child version will not be installed. Remove 485 this when the breakpoints module becomes aware of 486 inferiors and address spaces. */ 487 delete_step_resume_breakpoint (tp); 488 tp->control.step_range_start = 0; 489 tp->control.step_range_end = 0; 490 tp->control.step_frame_id = null_frame_id; 491 delete_exception_resume_breakpoint (tp); 492 } 493 494 parent = inferior_ptid; 495 child = tp->pending_follow.value.related_pid; 496 497 /* Tell the target to do whatever is necessary to follow 498 either parent or child. */ 499 if (target_follow_fork (follow_child)) 500 { 501 /* Target refused to follow, or there's some other reason 502 we shouldn't resume. */ 503 should_resume = 0; 504 } 505 else 506 { 507 /* This pending follow fork event is now handled, one way 508 or another. The previous selected thread may be gone 509 from the lists by now, but if it is still around, need 510 to clear the pending follow request. */ 511 tp = find_thread_ptid (parent); 512 if (tp) 513 tp->pending_follow.kind = TARGET_WAITKIND_SPURIOUS; 514 515 /* This makes sure we don't try to apply the "Switched 516 over from WAIT_PID" logic above. */ 517 nullify_last_target_wait_ptid (); 518 519 /* If we followed the child, switch to it... */ 520 if (follow_child) 521 { 522 switch_to_thread (child); 523 524 /* ... and preserve the stepping state, in case the 525 user was stepping over the fork call. */ 526 if (should_resume) 527 { 528 tp = inferior_thread (); 529 tp->control.step_resume_breakpoint 530 = step_resume_breakpoint; 531 tp->control.step_range_start = step_range_start; 532 tp->control.step_range_end = step_range_end; 533 tp->control.step_frame_id = step_frame_id; 534 tp->control.exception_resume_breakpoint 535 = exception_resume_breakpoint; 536 } 537 else 538 { 539 /* If we get here, it was because we're trying to 540 resume from a fork catchpoint, but, the user 541 has switched threads away from the thread that 542 forked. In that case, the resume command 543 issued is most likely not applicable to the 544 child, so just warn, and refuse to resume. */ 545 warning (_("Not resuming: switched threads " 546 "before following fork child.\n")); 547 } 548 549 /* Reset breakpoints in the child as appropriate. */ 550 follow_inferior_reset_breakpoints (); 551 } 552 else 553 switch_to_thread (parent); 554 } 555 } 556 break; 557 case TARGET_WAITKIND_SPURIOUS: 558 /* Nothing to follow. */ 559 break; 560 default: 561 internal_error (__FILE__, __LINE__, 562 "Unexpected pending_follow.kind %d\n", 563 tp->pending_follow.kind); 564 break; 565 } 566 567 return should_resume; 568 } 569 570 void 571 follow_inferior_reset_breakpoints (void) 572 { 573 struct thread_info *tp = inferior_thread (); 574 575 /* Was there a step_resume breakpoint? (There was if the user 576 did a "next" at the fork() call.) If so, explicitly reset its 577 thread number. 578 579 step_resumes are a form of bp that are made to be per-thread. 580 Since we created the step_resume bp when the parent process 581 was being debugged, and now are switching to the child process, 582 from the breakpoint package's viewpoint, that's a switch of 583 "threads". We must update the bp's notion of which thread 584 it is for, or it'll be ignored when it triggers. */ 585 586 if (tp->control.step_resume_breakpoint) 587 breakpoint_re_set_thread (tp->control.step_resume_breakpoint); 588 589 if (tp->control.exception_resume_breakpoint) 590 breakpoint_re_set_thread (tp->control.exception_resume_breakpoint); 591 592 /* Reinsert all breakpoints in the child. The user may have set 593 breakpoints after catching the fork, in which case those 594 were never set in the child, but only in the parent. This makes 595 sure the inserted breakpoints match the breakpoint list. */ 596 597 breakpoint_re_set (); 598 insert_breakpoints (); 599 } 600 601 /* The child has exited or execed: resume threads of the parent the 602 user wanted to be executing. */ 603 604 static int 605 proceed_after_vfork_done (struct thread_info *thread, 606 void *arg) 607 { 608 int pid = * (int *) arg; 609 610 if (ptid_get_pid (thread->ptid) == pid 611 && is_running (thread->ptid) 612 && !is_executing (thread->ptid) 613 && !thread->stop_requested 614 && thread->suspend.stop_signal == TARGET_SIGNAL_0) 615 { 616 if (debug_infrun) 617 fprintf_unfiltered (gdb_stdlog, 618 "infrun: resuming vfork parent thread %s\n", 619 target_pid_to_str (thread->ptid)); 620 621 switch_to_thread (thread->ptid); 622 clear_proceed_status (); 623 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0); 624 } 625 626 return 0; 627 } 628 629 /* Called whenever we notice an exec or exit event, to handle 630 detaching or resuming a vfork parent. */ 631 632 static void 633 handle_vfork_child_exec_or_exit (int exec) 634 { 635 struct inferior *inf = current_inferior (); 636 637 if (inf->vfork_parent) 638 { 639 int resume_parent = -1; 640 641 /* This exec or exit marks the end of the shared memory region 642 between the parent and the child. If the user wanted to 643 detach from the parent, now is the time. */ 644 645 if (inf->vfork_parent->pending_detach) 646 { 647 struct thread_info *tp; 648 struct cleanup *old_chain; 649 struct program_space *pspace; 650 struct address_space *aspace; 651 652 /* follow-fork child, detach-on-fork on. */ 653 654 old_chain = make_cleanup_restore_current_thread (); 655 656 /* We're letting loose of the parent. */ 657 tp = any_live_thread_of_process (inf->vfork_parent->pid); 658 switch_to_thread (tp->ptid); 659 660 /* We're about to detach from the parent, which implicitly 661 removes breakpoints from its address space. There's a 662 catch here: we want to reuse the spaces for the child, 663 but, parent/child are still sharing the pspace at this 664 point, although the exec in reality makes the kernel give 665 the child a fresh set of new pages. The problem here is 666 that the breakpoints module being unaware of this, would 667 likely chose the child process to write to the parent 668 address space. Swapping the child temporarily away from 669 the spaces has the desired effect. Yes, this is "sort 670 of" a hack. */ 671 672 pspace = inf->pspace; 673 aspace = inf->aspace; 674 inf->aspace = NULL; 675 inf->pspace = NULL; 676 677 if (debug_infrun || info_verbose) 678 { 679 target_terminal_ours (); 680 681 if (exec) 682 fprintf_filtered (gdb_stdlog, 683 "Detaching vfork parent process " 684 "%d after child exec.\n", 685 inf->vfork_parent->pid); 686 else 687 fprintf_filtered (gdb_stdlog, 688 "Detaching vfork parent process " 689 "%d after child exit.\n", 690 inf->vfork_parent->pid); 691 } 692 693 target_detach (NULL, 0); 694 695 /* Put it back. */ 696 inf->pspace = pspace; 697 inf->aspace = aspace; 698 699 do_cleanups (old_chain); 700 } 701 else if (exec) 702 { 703 /* We're staying attached to the parent, so, really give the 704 child a new address space. */ 705 inf->pspace = add_program_space (maybe_new_address_space ()); 706 inf->aspace = inf->pspace->aspace; 707 inf->removable = 1; 708 set_current_program_space (inf->pspace); 709 710 resume_parent = inf->vfork_parent->pid; 711 712 /* Break the bonds. */ 713 inf->vfork_parent->vfork_child = NULL; 714 } 715 else 716 { 717 struct cleanup *old_chain; 718 struct program_space *pspace; 719 720 /* If this is a vfork child exiting, then the pspace and 721 aspaces were shared with the parent. Since we're 722 reporting the process exit, we'll be mourning all that is 723 found in the address space, and switching to null_ptid, 724 preparing to start a new inferior. But, since we don't 725 want to clobber the parent's address/program spaces, we 726 go ahead and create a new one for this exiting 727 inferior. */ 728 729 /* Switch to null_ptid, so that clone_program_space doesn't want 730 to read the selected frame of a dead process. */ 731 old_chain = save_inferior_ptid (); 732 inferior_ptid = null_ptid; 733 734 /* This inferior is dead, so avoid giving the breakpoints 735 module the option to write through to it (cloning a 736 program space resets breakpoints). */ 737 inf->aspace = NULL; 738 inf->pspace = NULL; 739 pspace = add_program_space (maybe_new_address_space ()); 740 set_current_program_space (pspace); 741 inf->removable = 1; 742 clone_program_space (pspace, inf->vfork_parent->pspace); 743 inf->pspace = pspace; 744 inf->aspace = pspace->aspace; 745 746 /* Put back inferior_ptid. We'll continue mourning this 747 inferior. */ 748 do_cleanups (old_chain); 749 750 resume_parent = inf->vfork_parent->pid; 751 /* Break the bonds. */ 752 inf->vfork_parent->vfork_child = NULL; 753 } 754 755 inf->vfork_parent = NULL; 756 757 gdb_assert (current_program_space == inf->pspace); 758 759 if (non_stop && resume_parent != -1) 760 { 761 /* If the user wanted the parent to be running, let it go 762 free now. */ 763 struct cleanup *old_chain = make_cleanup_restore_current_thread (); 764 765 if (debug_infrun) 766 fprintf_unfiltered (gdb_stdlog, 767 "infrun: resuming vfork parent process %d\n", 768 resume_parent); 769 770 iterate_over_threads (proceed_after_vfork_done, &resume_parent); 771 772 do_cleanups (old_chain); 773 } 774 } 775 } 776 777 /* Enum strings for "set|show displaced-stepping". */ 778 779 static const char follow_exec_mode_new[] = "new"; 780 static const char follow_exec_mode_same[] = "same"; 781 static const char *follow_exec_mode_names[] = 782 { 783 follow_exec_mode_new, 784 follow_exec_mode_same, 785 NULL, 786 }; 787 788 static const char *follow_exec_mode_string = follow_exec_mode_same; 789 static void 790 show_follow_exec_mode_string (struct ui_file *file, int from_tty, 791 struct cmd_list_element *c, const char *value) 792 { 793 fprintf_filtered (file, _("Follow exec mode is \"%s\".\n"), value); 794 } 795 796 /* EXECD_PATHNAME is assumed to be non-NULL. */ 797 798 static void 799 follow_exec (ptid_t pid, char *execd_pathname) 800 { 801 struct thread_info *th = inferior_thread (); 802 struct inferior *inf = current_inferior (); 803 804 /* This is an exec event that we actually wish to pay attention to. 805 Refresh our symbol table to the newly exec'd program, remove any 806 momentary bp's, etc. 807 808 If there are breakpoints, they aren't really inserted now, 809 since the exec() transformed our inferior into a fresh set 810 of instructions. 811 812 We want to preserve symbolic breakpoints on the list, since 813 we have hopes that they can be reset after the new a.out's 814 symbol table is read. 815 816 However, any "raw" breakpoints must be removed from the list 817 (e.g., the solib bp's), since their address is probably invalid 818 now. 819 820 And, we DON'T want to call delete_breakpoints() here, since 821 that may write the bp's "shadow contents" (the instruction 822 value that was overwritten witha TRAP instruction). Since 823 we now have a new a.out, those shadow contents aren't valid. */ 824 825 mark_breakpoints_out (); 826 827 update_breakpoints_after_exec (); 828 829 /* If there was one, it's gone now. We cannot truly step-to-next 830 statement through an exec(). */ 831 th->control.step_resume_breakpoint = NULL; 832 th->control.exception_resume_breakpoint = NULL; 833 th->control.step_range_start = 0; 834 th->control.step_range_end = 0; 835 836 /* The target reports the exec event to the main thread, even if 837 some other thread does the exec, and even if the main thread was 838 already stopped --- if debugging in non-stop mode, it's possible 839 the user had the main thread held stopped in the previous image 840 --- release it now. This is the same behavior as step-over-exec 841 with scheduler-locking on in all-stop mode. */ 842 th->stop_requested = 0; 843 844 /* What is this a.out's name? */ 845 printf_unfiltered (_("%s is executing new program: %s\n"), 846 target_pid_to_str (inferior_ptid), 847 execd_pathname); 848 849 /* We've followed the inferior through an exec. Therefore, the 850 inferior has essentially been killed & reborn. */ 851 852 gdb_flush (gdb_stdout); 853 854 breakpoint_init_inferior (inf_execd); 855 856 if (gdb_sysroot && *gdb_sysroot) 857 { 858 char *name = alloca (strlen (gdb_sysroot) 859 + strlen (execd_pathname) 860 + 1); 861 862 strcpy (name, gdb_sysroot); 863 strcat (name, execd_pathname); 864 execd_pathname = name; 865 } 866 867 /* Reset the shared library package. This ensures that we get a 868 shlib event when the child reaches "_start", at which point the 869 dld will have had a chance to initialize the child. */ 870 /* Also, loading a symbol file below may trigger symbol lookups, and 871 we don't want those to be satisfied by the libraries of the 872 previous incarnation of this process. */ 873 no_shared_libraries (NULL, 0); 874 875 if (follow_exec_mode_string == follow_exec_mode_new) 876 { 877 struct program_space *pspace; 878 879 /* The user wants to keep the old inferior and program spaces 880 around. Create a new fresh one, and switch to it. */ 881 882 inf = add_inferior (current_inferior ()->pid); 883 pspace = add_program_space (maybe_new_address_space ()); 884 inf->pspace = pspace; 885 inf->aspace = pspace->aspace; 886 887 exit_inferior_num_silent (current_inferior ()->num); 888 889 set_current_inferior (inf); 890 set_current_program_space (pspace); 891 } 892 893 gdb_assert (current_program_space == inf->pspace); 894 895 /* That a.out is now the one to use. */ 896 exec_file_attach (execd_pathname, 0); 897 898 /* SYMFILE_DEFER_BP_RESET is used as the proper displacement for PIE 899 (Position Independent Executable) main symbol file will get applied by 900 solib_create_inferior_hook below. breakpoint_re_set would fail to insert 901 the breakpoints with the zero displacement. */ 902 903 symbol_file_add (execd_pathname, SYMFILE_MAINLINE | SYMFILE_DEFER_BP_RESET, 904 NULL, 0); 905 906 set_initial_language (); 907 908 #ifdef SOLIB_CREATE_INFERIOR_HOOK 909 SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid)); 910 #else 911 solib_create_inferior_hook (0); 912 #endif 913 914 jit_inferior_created_hook (); 915 916 breakpoint_re_set (); 917 918 /* Reinsert all breakpoints. (Those which were symbolic have 919 been reset to the proper address in the new a.out, thanks 920 to symbol_file_command...). */ 921 insert_breakpoints (); 922 923 /* The next resume of this inferior should bring it to the shlib 924 startup breakpoints. (If the user had also set bp's on 925 "main" from the old (parent) process, then they'll auto- 926 matically get reset there in the new process.). */ 927 } 928 929 /* Non-zero if we just simulating a single-step. This is needed 930 because we cannot remove the breakpoints in the inferior process 931 until after the `wait' in `wait_for_inferior'. */ 932 static int singlestep_breakpoints_inserted_p = 0; 933 934 /* The thread we inserted single-step breakpoints for. */ 935 static ptid_t singlestep_ptid; 936 937 /* PC when we started this single-step. */ 938 static CORE_ADDR singlestep_pc; 939 940 /* If another thread hit the singlestep breakpoint, we save the original 941 thread here so that we can resume single-stepping it later. */ 942 static ptid_t saved_singlestep_ptid; 943 static int stepping_past_singlestep_breakpoint; 944 945 /* If not equal to null_ptid, this means that after stepping over breakpoint 946 is finished, we need to switch to deferred_step_ptid, and step it. 947 948 The use case is when one thread has hit a breakpoint, and then the user 949 has switched to another thread and issued 'step'. We need to step over 950 breakpoint in the thread which hit the breakpoint, but then continue 951 stepping the thread user has selected. */ 952 static ptid_t deferred_step_ptid; 953 954 /* Displaced stepping. */ 955 956 /* In non-stop debugging mode, we must take special care to manage 957 breakpoints properly; in particular, the traditional strategy for 958 stepping a thread past a breakpoint it has hit is unsuitable. 959 'Displaced stepping' is a tactic for stepping one thread past a 960 breakpoint it has hit while ensuring that other threads running 961 concurrently will hit the breakpoint as they should. 962 963 The traditional way to step a thread T off a breakpoint in a 964 multi-threaded program in all-stop mode is as follows: 965 966 a0) Initially, all threads are stopped, and breakpoints are not 967 inserted. 968 a1) We single-step T, leaving breakpoints uninserted. 969 a2) We insert breakpoints, and resume all threads. 970 971 In non-stop debugging, however, this strategy is unsuitable: we 972 don't want to have to stop all threads in the system in order to 973 continue or step T past a breakpoint. Instead, we use displaced 974 stepping: 975 976 n0) Initially, T is stopped, other threads are running, and 977 breakpoints are inserted. 978 n1) We copy the instruction "under" the breakpoint to a separate 979 location, outside the main code stream, making any adjustments 980 to the instruction, register, and memory state as directed by 981 T's architecture. 982 n2) We single-step T over the instruction at its new location. 983 n3) We adjust the resulting register and memory state as directed 984 by T's architecture. This includes resetting T's PC to point 985 back into the main instruction stream. 986 n4) We resume T. 987 988 This approach depends on the following gdbarch methods: 989 990 - gdbarch_max_insn_length and gdbarch_displaced_step_location 991 indicate where to copy the instruction, and how much space must 992 be reserved there. We use these in step n1. 993 994 - gdbarch_displaced_step_copy_insn copies a instruction to a new 995 address, and makes any necessary adjustments to the instruction, 996 register contents, and memory. We use this in step n1. 997 998 - gdbarch_displaced_step_fixup adjusts registers and memory after 999 we have successfuly single-stepped the instruction, to yield the 1000 same effect the instruction would have had if we had executed it 1001 at its original address. We use this in step n3. 1002 1003 - gdbarch_displaced_step_free_closure provides cleanup. 1004 1005 The gdbarch_displaced_step_copy_insn and 1006 gdbarch_displaced_step_fixup functions must be written so that 1007 copying an instruction with gdbarch_displaced_step_copy_insn, 1008 single-stepping across the copied instruction, and then applying 1009 gdbarch_displaced_insn_fixup should have the same effects on the 1010 thread's memory and registers as stepping the instruction in place 1011 would have. Exactly which responsibilities fall to the copy and 1012 which fall to the fixup is up to the author of those functions. 1013 1014 See the comments in gdbarch.sh for details. 1015 1016 Note that displaced stepping and software single-step cannot 1017 currently be used in combination, although with some care I think 1018 they could be made to. Software single-step works by placing 1019 breakpoints on all possible subsequent instructions; if the 1020 displaced instruction is a PC-relative jump, those breakpoints 1021 could fall in very strange places --- on pages that aren't 1022 executable, or at addresses that are not proper instruction 1023 boundaries. (We do generally let other threads run while we wait 1024 to hit the software single-step breakpoint, and they might 1025 encounter such a corrupted instruction.) One way to work around 1026 this would be to have gdbarch_displaced_step_copy_insn fully 1027 simulate the effect of PC-relative instructions (and return NULL) 1028 on architectures that use software single-stepping. 1029 1030 In non-stop mode, we can have independent and simultaneous step 1031 requests, so more than one thread may need to simultaneously step 1032 over a breakpoint. The current implementation assumes there is 1033 only one scratch space per process. In this case, we have to 1034 serialize access to the scratch space. If thread A wants to step 1035 over a breakpoint, but we are currently waiting for some other 1036 thread to complete a displaced step, we leave thread A stopped and 1037 place it in the displaced_step_request_queue. Whenever a displaced 1038 step finishes, we pick the next thread in the queue and start a new 1039 displaced step operation on it. See displaced_step_prepare and 1040 displaced_step_fixup for details. */ 1041 1042 struct displaced_step_request 1043 { 1044 ptid_t ptid; 1045 struct displaced_step_request *next; 1046 }; 1047 1048 /* Per-inferior displaced stepping state. */ 1049 struct displaced_step_inferior_state 1050 { 1051 /* Pointer to next in linked list. */ 1052 struct displaced_step_inferior_state *next; 1053 1054 /* The process this displaced step state refers to. */ 1055 int pid; 1056 1057 /* A queue of pending displaced stepping requests. One entry per 1058 thread that needs to do a displaced step. */ 1059 struct displaced_step_request *step_request_queue; 1060 1061 /* If this is not null_ptid, this is the thread carrying out a 1062 displaced single-step in process PID. This thread's state will 1063 require fixing up once it has completed its step. */ 1064 ptid_t step_ptid; 1065 1066 /* The architecture the thread had when we stepped it. */ 1067 struct gdbarch *step_gdbarch; 1068 1069 /* The closure provided gdbarch_displaced_step_copy_insn, to be used 1070 for post-step cleanup. */ 1071 struct displaced_step_closure *step_closure; 1072 1073 /* The address of the original instruction, and the copy we 1074 made. */ 1075 CORE_ADDR step_original, step_copy; 1076 1077 /* Saved contents of copy area. */ 1078 gdb_byte *step_saved_copy; 1079 }; 1080 1081 /* The list of states of processes involved in displaced stepping 1082 presently. */ 1083 static struct displaced_step_inferior_state *displaced_step_inferior_states; 1084 1085 /* Get the displaced stepping state of process PID. */ 1086 1087 static struct displaced_step_inferior_state * 1088 get_displaced_stepping_state (int pid) 1089 { 1090 struct displaced_step_inferior_state *state; 1091 1092 for (state = displaced_step_inferior_states; 1093 state != NULL; 1094 state = state->next) 1095 if (state->pid == pid) 1096 return state; 1097 1098 return NULL; 1099 } 1100 1101 /* Add a new displaced stepping state for process PID to the displaced 1102 stepping state list, or return a pointer to an already existing 1103 entry, if it already exists. Never returns NULL. */ 1104 1105 static struct displaced_step_inferior_state * 1106 add_displaced_stepping_state (int pid) 1107 { 1108 struct displaced_step_inferior_state *state; 1109 1110 for (state = displaced_step_inferior_states; 1111 state != NULL; 1112 state = state->next) 1113 if (state->pid == pid) 1114 return state; 1115 1116 state = xcalloc (1, sizeof (*state)); 1117 state->pid = pid; 1118 state->next = displaced_step_inferior_states; 1119 displaced_step_inferior_states = state; 1120 1121 return state; 1122 } 1123 1124 /* If inferior is in displaced stepping, and ADDR equals to starting address 1125 of copy area, return corresponding displaced_step_closure. Otherwise, 1126 return NULL. */ 1127 1128 struct displaced_step_closure* 1129 get_displaced_step_closure_by_addr (CORE_ADDR addr) 1130 { 1131 struct displaced_step_inferior_state *displaced 1132 = get_displaced_stepping_state (ptid_get_pid (inferior_ptid)); 1133 1134 /* If checking the mode of displaced instruction in copy area. */ 1135 if (displaced && !ptid_equal (displaced->step_ptid, null_ptid) 1136 && (displaced->step_copy == addr)) 1137 return displaced->step_closure; 1138 1139 return NULL; 1140 } 1141 1142 /* Remove the displaced stepping state of process PID. */ 1143 1144 static void 1145 remove_displaced_stepping_state (int pid) 1146 { 1147 struct displaced_step_inferior_state *it, **prev_next_p; 1148 1149 gdb_assert (pid != FAKE_PROCESS_ID); 1150 1151 it = displaced_step_inferior_states; 1152 prev_next_p = &displaced_step_inferior_states; 1153 while (it) 1154 { 1155 if (it->pid == pid) 1156 { 1157 *prev_next_p = it->next; 1158 xfree (it); 1159 return; 1160 } 1161 1162 prev_next_p = &it->next; 1163 it = *prev_next_p; 1164 } 1165 } 1166 1167 static void 1168 infrun_inferior_exit (struct inferior *inf) 1169 { 1170 remove_displaced_stepping_state (inf->pid); 1171 } 1172 1173 /* Enum strings for "set|show displaced-stepping". */ 1174 1175 static const char can_use_displaced_stepping_auto[] = "auto"; 1176 static const char can_use_displaced_stepping_on[] = "on"; 1177 static const char can_use_displaced_stepping_off[] = "off"; 1178 static const char *can_use_displaced_stepping_enum[] = 1179 { 1180 can_use_displaced_stepping_auto, 1181 can_use_displaced_stepping_on, 1182 can_use_displaced_stepping_off, 1183 NULL, 1184 }; 1185 1186 /* If ON, and the architecture supports it, GDB will use displaced 1187 stepping to step over breakpoints. If OFF, or if the architecture 1188 doesn't support it, GDB will instead use the traditional 1189 hold-and-step approach. If AUTO (which is the default), GDB will 1190 decide which technique to use to step over breakpoints depending on 1191 which of all-stop or non-stop mode is active --- displaced stepping 1192 in non-stop mode; hold-and-step in all-stop mode. */ 1193 1194 static const char *can_use_displaced_stepping = 1195 can_use_displaced_stepping_auto; 1196 1197 static void 1198 show_can_use_displaced_stepping (struct ui_file *file, int from_tty, 1199 struct cmd_list_element *c, 1200 const char *value) 1201 { 1202 if (can_use_displaced_stepping == can_use_displaced_stepping_auto) 1203 fprintf_filtered (file, 1204 _("Debugger's willingness to use displaced stepping " 1205 "to step over breakpoints is %s (currently %s).\n"), 1206 value, non_stop ? "on" : "off"); 1207 else 1208 fprintf_filtered (file, 1209 _("Debugger's willingness to use displaced stepping " 1210 "to step over breakpoints is %s.\n"), value); 1211 } 1212 1213 /* Return non-zero if displaced stepping can/should be used to step 1214 over breakpoints. */ 1215 1216 static int 1217 use_displaced_stepping (struct gdbarch *gdbarch) 1218 { 1219 return (((can_use_displaced_stepping == can_use_displaced_stepping_auto 1220 && non_stop) 1221 || can_use_displaced_stepping == can_use_displaced_stepping_on) 1222 && gdbarch_displaced_step_copy_insn_p (gdbarch) 1223 && !RECORD_IS_USED); 1224 } 1225 1226 /* Clean out any stray displaced stepping state. */ 1227 static void 1228 displaced_step_clear (struct displaced_step_inferior_state *displaced) 1229 { 1230 /* Indicate that there is no cleanup pending. */ 1231 displaced->step_ptid = null_ptid; 1232 1233 if (displaced->step_closure) 1234 { 1235 gdbarch_displaced_step_free_closure (displaced->step_gdbarch, 1236 displaced->step_closure); 1237 displaced->step_closure = NULL; 1238 } 1239 } 1240 1241 static void 1242 displaced_step_clear_cleanup (void *arg) 1243 { 1244 struct displaced_step_inferior_state *state = arg; 1245 1246 displaced_step_clear (state); 1247 } 1248 1249 /* Dump LEN bytes at BUF in hex to FILE, followed by a newline. */ 1250 void 1251 displaced_step_dump_bytes (struct ui_file *file, 1252 const gdb_byte *buf, 1253 size_t len) 1254 { 1255 int i; 1256 1257 for (i = 0; i < len; i++) 1258 fprintf_unfiltered (file, "%02x ", buf[i]); 1259 fputs_unfiltered ("\n", file); 1260 } 1261 1262 /* Prepare to single-step, using displaced stepping. 1263 1264 Note that we cannot use displaced stepping when we have a signal to 1265 deliver. If we have a signal to deliver and an instruction to step 1266 over, then after the step, there will be no indication from the 1267 target whether the thread entered a signal handler or ignored the 1268 signal and stepped over the instruction successfully --- both cases 1269 result in a simple SIGTRAP. In the first case we mustn't do a 1270 fixup, and in the second case we must --- but we can't tell which. 1271 Comments in the code for 'random signals' in handle_inferior_event 1272 explain how we handle this case instead. 1273 1274 Returns 1 if preparing was successful -- this thread is going to be 1275 stepped now; or 0 if displaced stepping this thread got queued. */ 1276 static int 1277 displaced_step_prepare (ptid_t ptid) 1278 { 1279 struct cleanup *old_cleanups, *ignore_cleanups; 1280 struct regcache *regcache = get_thread_regcache (ptid); 1281 struct gdbarch *gdbarch = get_regcache_arch (regcache); 1282 CORE_ADDR original, copy; 1283 ULONGEST len; 1284 struct displaced_step_closure *closure; 1285 struct displaced_step_inferior_state *displaced; 1286 1287 /* We should never reach this function if the architecture does not 1288 support displaced stepping. */ 1289 gdb_assert (gdbarch_displaced_step_copy_insn_p (gdbarch)); 1290 1291 /* We have to displaced step one thread at a time, as we only have 1292 access to a single scratch space per inferior. */ 1293 1294 displaced = add_displaced_stepping_state (ptid_get_pid (ptid)); 1295 1296 if (!ptid_equal (displaced->step_ptid, null_ptid)) 1297 { 1298 /* Already waiting for a displaced step to finish. Defer this 1299 request and place in queue. */ 1300 struct displaced_step_request *req, *new_req; 1301 1302 if (debug_displaced) 1303 fprintf_unfiltered (gdb_stdlog, 1304 "displaced: defering step of %s\n", 1305 target_pid_to_str (ptid)); 1306 1307 new_req = xmalloc (sizeof (*new_req)); 1308 new_req->ptid = ptid; 1309 new_req->next = NULL; 1310 1311 if (displaced->step_request_queue) 1312 { 1313 for (req = displaced->step_request_queue; 1314 req && req->next; 1315 req = req->next) 1316 ; 1317 req->next = new_req; 1318 } 1319 else 1320 displaced->step_request_queue = new_req; 1321 1322 return 0; 1323 } 1324 else 1325 { 1326 if (debug_displaced) 1327 fprintf_unfiltered (gdb_stdlog, 1328 "displaced: stepping %s now\n", 1329 target_pid_to_str (ptid)); 1330 } 1331 1332 displaced_step_clear (displaced); 1333 1334 old_cleanups = save_inferior_ptid (); 1335 inferior_ptid = ptid; 1336 1337 original = regcache_read_pc (regcache); 1338 1339 copy = gdbarch_displaced_step_location (gdbarch); 1340 len = gdbarch_max_insn_length (gdbarch); 1341 1342 /* Save the original contents of the copy area. */ 1343 displaced->step_saved_copy = xmalloc (len); 1344 ignore_cleanups = make_cleanup (free_current_contents, 1345 &displaced->step_saved_copy); 1346 read_memory (copy, displaced->step_saved_copy, len); 1347 if (debug_displaced) 1348 { 1349 fprintf_unfiltered (gdb_stdlog, "displaced: saved %s: ", 1350 paddress (gdbarch, copy)); 1351 displaced_step_dump_bytes (gdb_stdlog, 1352 displaced->step_saved_copy, 1353 len); 1354 }; 1355 1356 closure = gdbarch_displaced_step_copy_insn (gdbarch, 1357 original, copy, regcache); 1358 1359 /* We don't support the fully-simulated case at present. */ 1360 gdb_assert (closure); 1361 1362 /* Save the information we need to fix things up if the step 1363 succeeds. */ 1364 displaced->step_ptid = ptid; 1365 displaced->step_gdbarch = gdbarch; 1366 displaced->step_closure = closure; 1367 displaced->step_original = original; 1368 displaced->step_copy = copy; 1369 1370 make_cleanup (displaced_step_clear_cleanup, displaced); 1371 1372 /* Resume execution at the copy. */ 1373 regcache_write_pc (regcache, copy); 1374 1375 discard_cleanups (ignore_cleanups); 1376 1377 do_cleanups (old_cleanups); 1378 1379 if (debug_displaced) 1380 fprintf_unfiltered (gdb_stdlog, "displaced: displaced pc to %s\n", 1381 paddress (gdbarch, copy)); 1382 1383 return 1; 1384 } 1385 1386 static void 1387 write_memory_ptid (ptid_t ptid, CORE_ADDR memaddr, 1388 const gdb_byte *myaddr, int len) 1389 { 1390 struct cleanup *ptid_cleanup = save_inferior_ptid (); 1391 1392 inferior_ptid = ptid; 1393 write_memory (memaddr, myaddr, len); 1394 do_cleanups (ptid_cleanup); 1395 } 1396 1397 /* Restore the contents of the copy area for thread PTID. */ 1398 1399 static void 1400 displaced_step_restore (struct displaced_step_inferior_state *displaced, 1401 ptid_t ptid) 1402 { 1403 ULONGEST len = gdbarch_max_insn_length (displaced->step_gdbarch); 1404 1405 write_memory_ptid (ptid, displaced->step_copy, 1406 displaced->step_saved_copy, len); 1407 if (debug_displaced) 1408 fprintf_unfiltered (gdb_stdlog, "displaced: restored %s %s\n", 1409 target_pid_to_str (ptid), 1410 paddress (displaced->step_gdbarch, 1411 displaced->step_copy)); 1412 } 1413 1414 static void 1415 displaced_step_fixup (ptid_t event_ptid, enum target_signal signal) 1416 { 1417 struct cleanup *old_cleanups; 1418 struct displaced_step_inferior_state *displaced 1419 = get_displaced_stepping_state (ptid_get_pid (event_ptid)); 1420 1421 /* Was any thread of this process doing a displaced step? */ 1422 if (displaced == NULL) 1423 return; 1424 1425 /* Was this event for the pid we displaced? */ 1426 if (ptid_equal (displaced->step_ptid, null_ptid) 1427 || ! ptid_equal (displaced->step_ptid, event_ptid)) 1428 return; 1429 1430 old_cleanups = make_cleanup (displaced_step_clear_cleanup, displaced); 1431 1432 displaced_step_restore (displaced, displaced->step_ptid); 1433 1434 /* Did the instruction complete successfully? */ 1435 if (signal == TARGET_SIGNAL_TRAP) 1436 { 1437 /* Fix up the resulting state. */ 1438 gdbarch_displaced_step_fixup (displaced->step_gdbarch, 1439 displaced->step_closure, 1440 displaced->step_original, 1441 displaced->step_copy, 1442 get_thread_regcache (displaced->step_ptid)); 1443 } 1444 else 1445 { 1446 /* Since the instruction didn't complete, all we can do is 1447 relocate the PC. */ 1448 struct regcache *regcache = get_thread_regcache (event_ptid); 1449 CORE_ADDR pc = regcache_read_pc (regcache); 1450 1451 pc = displaced->step_original + (pc - displaced->step_copy); 1452 regcache_write_pc (regcache, pc); 1453 } 1454 1455 do_cleanups (old_cleanups); 1456 1457 displaced->step_ptid = null_ptid; 1458 1459 /* Are there any pending displaced stepping requests? If so, run 1460 one now. Leave the state object around, since we're likely to 1461 need it again soon. */ 1462 while (displaced->step_request_queue) 1463 { 1464 struct displaced_step_request *head; 1465 ptid_t ptid; 1466 struct regcache *regcache; 1467 struct gdbarch *gdbarch; 1468 CORE_ADDR actual_pc; 1469 struct address_space *aspace; 1470 1471 head = displaced->step_request_queue; 1472 ptid = head->ptid; 1473 displaced->step_request_queue = head->next; 1474 xfree (head); 1475 1476 context_switch (ptid); 1477 1478 regcache = get_thread_regcache (ptid); 1479 actual_pc = regcache_read_pc (regcache); 1480 aspace = get_regcache_aspace (regcache); 1481 1482 if (breakpoint_here_p (aspace, actual_pc)) 1483 { 1484 if (debug_displaced) 1485 fprintf_unfiltered (gdb_stdlog, 1486 "displaced: stepping queued %s now\n", 1487 target_pid_to_str (ptid)); 1488 1489 displaced_step_prepare (ptid); 1490 1491 gdbarch = get_regcache_arch (regcache); 1492 1493 if (debug_displaced) 1494 { 1495 CORE_ADDR actual_pc = regcache_read_pc (regcache); 1496 gdb_byte buf[4]; 1497 1498 fprintf_unfiltered (gdb_stdlog, "displaced: run %s: ", 1499 paddress (gdbarch, actual_pc)); 1500 read_memory (actual_pc, buf, sizeof (buf)); 1501 displaced_step_dump_bytes (gdb_stdlog, buf, sizeof (buf)); 1502 } 1503 1504 if (gdbarch_displaced_step_hw_singlestep (gdbarch, 1505 displaced->step_closure)) 1506 target_resume (ptid, 1, TARGET_SIGNAL_0); 1507 else 1508 target_resume (ptid, 0, TARGET_SIGNAL_0); 1509 1510 /* Done, we're stepping a thread. */ 1511 break; 1512 } 1513 else 1514 { 1515 int step; 1516 struct thread_info *tp = inferior_thread (); 1517 1518 /* The breakpoint we were sitting under has since been 1519 removed. */ 1520 tp->control.trap_expected = 0; 1521 1522 /* Go back to what we were trying to do. */ 1523 step = currently_stepping (tp); 1524 1525 if (debug_displaced) 1526 fprintf_unfiltered (gdb_stdlog, 1527 "breakpoint is gone %s: step(%d)\n", 1528 target_pid_to_str (tp->ptid), step); 1529 1530 target_resume (ptid, step, TARGET_SIGNAL_0); 1531 tp->suspend.stop_signal = TARGET_SIGNAL_0; 1532 1533 /* This request was discarded. See if there's any other 1534 thread waiting for its turn. */ 1535 } 1536 } 1537 } 1538 1539 /* Update global variables holding ptids to hold NEW_PTID if they were 1540 holding OLD_PTID. */ 1541 static void 1542 infrun_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid) 1543 { 1544 struct displaced_step_request *it; 1545 struct displaced_step_inferior_state *displaced; 1546 1547 if (ptid_equal (inferior_ptid, old_ptid)) 1548 inferior_ptid = new_ptid; 1549 1550 if (ptid_equal (singlestep_ptid, old_ptid)) 1551 singlestep_ptid = new_ptid; 1552 1553 if (ptid_equal (deferred_step_ptid, old_ptid)) 1554 deferred_step_ptid = new_ptid; 1555 1556 for (displaced = displaced_step_inferior_states; 1557 displaced; 1558 displaced = displaced->next) 1559 { 1560 if (ptid_equal (displaced->step_ptid, old_ptid)) 1561 displaced->step_ptid = new_ptid; 1562 1563 for (it = displaced->step_request_queue; it; it = it->next) 1564 if (ptid_equal (it->ptid, old_ptid)) 1565 it->ptid = new_ptid; 1566 } 1567 } 1568 1569 1570 /* Resuming. */ 1571 1572 /* Things to clean up if we QUIT out of resume (). */ 1573 static void 1574 resume_cleanups (void *ignore) 1575 { 1576 normal_stop (); 1577 } 1578 1579 static const char schedlock_off[] = "off"; 1580 static const char schedlock_on[] = "on"; 1581 static const char schedlock_step[] = "step"; 1582 static const char *scheduler_enums[] = { 1583 schedlock_off, 1584 schedlock_on, 1585 schedlock_step, 1586 NULL 1587 }; 1588 static const char *scheduler_mode = schedlock_off; 1589 static void 1590 show_scheduler_mode (struct ui_file *file, int from_tty, 1591 struct cmd_list_element *c, const char *value) 1592 { 1593 fprintf_filtered (file, 1594 _("Mode for locking scheduler " 1595 "during execution is \"%s\".\n"), 1596 value); 1597 } 1598 1599 static void 1600 set_schedlock_func (char *args, int from_tty, struct cmd_list_element *c) 1601 { 1602 if (!target_can_lock_scheduler) 1603 { 1604 scheduler_mode = schedlock_off; 1605 error (_("Target '%s' cannot support this command."), target_shortname); 1606 } 1607 } 1608 1609 /* True if execution commands resume all threads of all processes by 1610 default; otherwise, resume only threads of the current inferior 1611 process. */ 1612 int sched_multi = 0; 1613 1614 /* Try to setup for software single stepping over the specified location. 1615 Return 1 if target_resume() should use hardware single step. 1616 1617 GDBARCH the current gdbarch. 1618 PC the location to step over. */ 1619 1620 static int 1621 maybe_software_singlestep (struct gdbarch *gdbarch, CORE_ADDR pc) 1622 { 1623 int hw_step = 1; 1624 1625 if (execution_direction == EXEC_FORWARD 1626 && gdbarch_software_single_step_p (gdbarch) 1627 && gdbarch_software_single_step (gdbarch, get_current_frame ())) 1628 { 1629 hw_step = 0; 1630 /* Do not pull these breakpoints until after a `wait' in 1631 `wait_for_inferior'. */ 1632 singlestep_breakpoints_inserted_p = 1; 1633 singlestep_ptid = inferior_ptid; 1634 singlestep_pc = pc; 1635 } 1636 return hw_step; 1637 } 1638 1639 /* Return a ptid representing the set of threads that we will proceed, 1640 in the perspective of the user/frontend. We may actually resume 1641 fewer threads at first, e.g., if a thread is stopped at a 1642 breakpoint that needs stepping-off, but that should not be visible 1643 to the user/frontend, and neither should the frontend/user be 1644 allowed to proceed any of the threads that happen to be stopped for 1645 internal run control handling, if a previous command wanted them 1646 resumed. */ 1647 1648 ptid_t 1649 user_visible_resume_ptid (int step) 1650 { 1651 /* By default, resume all threads of all processes. */ 1652 ptid_t resume_ptid = RESUME_ALL; 1653 1654 /* Maybe resume only all threads of the current process. */ 1655 if (!sched_multi && target_supports_multi_process ()) 1656 { 1657 resume_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid)); 1658 } 1659 1660 /* Maybe resume a single thread after all. */ 1661 if (non_stop) 1662 { 1663 /* With non-stop mode on, threads are always handled 1664 individually. */ 1665 resume_ptid = inferior_ptid; 1666 } 1667 else if ((scheduler_mode == schedlock_on) 1668 || (scheduler_mode == schedlock_step 1669 && (step || singlestep_breakpoints_inserted_p))) 1670 { 1671 /* User-settable 'scheduler' mode requires solo thread resume. */ 1672 resume_ptid = inferior_ptid; 1673 } 1674 1675 return resume_ptid; 1676 } 1677 1678 /* Resume the inferior, but allow a QUIT. This is useful if the user 1679 wants to interrupt some lengthy single-stepping operation 1680 (for child processes, the SIGINT goes to the inferior, and so 1681 we get a SIGINT random_signal, but for remote debugging and perhaps 1682 other targets, that's not true). 1683 1684 STEP nonzero if we should step (zero to continue instead). 1685 SIG is the signal to give the inferior (zero for none). */ 1686 void 1687 resume (int step, enum target_signal sig) 1688 { 1689 int should_resume = 1; 1690 struct cleanup *old_cleanups = make_cleanup (resume_cleanups, 0); 1691 struct regcache *regcache = get_current_regcache (); 1692 struct gdbarch *gdbarch = get_regcache_arch (regcache); 1693 struct thread_info *tp = inferior_thread (); 1694 CORE_ADDR pc = regcache_read_pc (regcache); 1695 struct address_space *aspace = get_regcache_aspace (regcache); 1696 1697 QUIT; 1698 1699 if (current_inferior ()->waiting_for_vfork_done) 1700 { 1701 /* Don't try to single-step a vfork parent that is waiting for 1702 the child to get out of the shared memory region (by exec'ing 1703 or exiting). This is particularly important on software 1704 single-step archs, as the child process would trip on the 1705 software single step breakpoint inserted for the parent 1706 process. Since the parent will not actually execute any 1707 instruction until the child is out of the shared region (such 1708 are vfork's semantics), it is safe to simply continue it. 1709 Eventually, we'll see a TARGET_WAITKIND_VFORK_DONE event for 1710 the parent, and tell it to `keep_going', which automatically 1711 re-sets it stepping. */ 1712 if (debug_infrun) 1713 fprintf_unfiltered (gdb_stdlog, 1714 "infrun: resume : clear step\n"); 1715 step = 0; 1716 } 1717 1718 if (debug_infrun) 1719 fprintf_unfiltered (gdb_stdlog, 1720 "infrun: resume (step=%d, signal=%d), " 1721 "trap_expected=%d, current thread [%s] at %s\n", 1722 step, sig, tp->control.trap_expected, 1723 target_pid_to_str (inferior_ptid), 1724 paddress (gdbarch, pc)); 1725 1726 /* Normally, by the time we reach `resume', the breakpoints are either 1727 removed or inserted, as appropriate. The exception is if we're sitting 1728 at a permanent breakpoint; we need to step over it, but permanent 1729 breakpoints can't be removed. So we have to test for it here. */ 1730 if (breakpoint_here_p (aspace, pc) == permanent_breakpoint_here) 1731 { 1732 if (gdbarch_skip_permanent_breakpoint_p (gdbarch)) 1733 gdbarch_skip_permanent_breakpoint (gdbarch, regcache); 1734 else 1735 error (_("\ 1736 The program is stopped at a permanent breakpoint, but GDB does not know\n\ 1737 how to step past a permanent breakpoint on this architecture. Try using\n\ 1738 a command like `return' or `jump' to continue execution.")); 1739 } 1740 1741 /* If enabled, step over breakpoints by executing a copy of the 1742 instruction at a different address. 1743 1744 We can't use displaced stepping when we have a signal to deliver; 1745 the comments for displaced_step_prepare explain why. The 1746 comments in the handle_inferior event for dealing with 'random 1747 signals' explain what we do instead. 1748 1749 We can't use displaced stepping when we are waiting for vfork_done 1750 event, displaced stepping breaks the vfork child similarly as single 1751 step software breakpoint. */ 1752 if (use_displaced_stepping (gdbarch) 1753 && (tp->control.trap_expected 1754 || (step && gdbarch_software_single_step_p (gdbarch))) 1755 && sig == TARGET_SIGNAL_0 1756 && !current_inferior ()->waiting_for_vfork_done) 1757 { 1758 struct displaced_step_inferior_state *displaced; 1759 1760 if (!displaced_step_prepare (inferior_ptid)) 1761 { 1762 /* Got placed in displaced stepping queue. Will be resumed 1763 later when all the currently queued displaced stepping 1764 requests finish. The thread is not executing at this point, 1765 and the call to set_executing will be made later. But we 1766 need to call set_running here, since from frontend point of view, 1767 the thread is running. */ 1768 set_running (inferior_ptid, 1); 1769 discard_cleanups (old_cleanups); 1770 return; 1771 } 1772 1773 displaced = get_displaced_stepping_state (ptid_get_pid (inferior_ptid)); 1774 step = gdbarch_displaced_step_hw_singlestep (gdbarch, 1775 displaced->step_closure); 1776 } 1777 1778 /* Do we need to do it the hard way, w/temp breakpoints? */ 1779 else if (step) 1780 step = maybe_software_singlestep (gdbarch, pc); 1781 1782 /* Currently, our software single-step implementation leads to different 1783 results than hardware single-stepping in one situation: when stepping 1784 into delivering a signal which has an associated signal handler, 1785 hardware single-step will stop at the first instruction of the handler, 1786 while software single-step will simply skip execution of the handler. 1787 1788 For now, this difference in behavior is accepted since there is no 1789 easy way to actually implement single-stepping into a signal handler 1790 without kernel support. 1791 1792 However, there is one scenario where this difference leads to follow-on 1793 problems: if we're stepping off a breakpoint by removing all breakpoints 1794 and then single-stepping. In this case, the software single-step 1795 behavior means that even if there is a *breakpoint* in the signal 1796 handler, GDB still would not stop. 1797 1798 Fortunately, we can at least fix this particular issue. We detect 1799 here the case where we are about to deliver a signal while software 1800 single-stepping with breakpoints removed. In this situation, we 1801 revert the decisions to remove all breakpoints and insert single- 1802 step breakpoints, and instead we install a step-resume breakpoint 1803 at the current address, deliver the signal without stepping, and 1804 once we arrive back at the step-resume breakpoint, actually step 1805 over the breakpoint we originally wanted to step over. */ 1806 if (singlestep_breakpoints_inserted_p 1807 && tp->control.trap_expected && sig != TARGET_SIGNAL_0) 1808 { 1809 /* If we have nested signals or a pending signal is delivered 1810 immediately after a handler returns, might might already have 1811 a step-resume breakpoint set on the earlier handler. We cannot 1812 set another step-resume breakpoint; just continue on until the 1813 original breakpoint is hit. */ 1814 if (tp->control.step_resume_breakpoint == NULL) 1815 { 1816 insert_hp_step_resume_breakpoint_at_frame (get_current_frame ()); 1817 tp->step_after_step_resume_breakpoint = 1; 1818 } 1819 1820 remove_single_step_breakpoints (); 1821 singlestep_breakpoints_inserted_p = 0; 1822 1823 insert_breakpoints (); 1824 tp->control.trap_expected = 0; 1825 } 1826 1827 if (should_resume) 1828 { 1829 ptid_t resume_ptid; 1830 1831 /* If STEP is set, it's a request to use hardware stepping 1832 facilities. But in that case, we should never 1833 use singlestep breakpoint. */ 1834 gdb_assert (!(singlestep_breakpoints_inserted_p && step)); 1835 1836 /* Decide the set of threads to ask the target to resume. Start 1837 by assuming everything will be resumed, than narrow the set 1838 by applying increasingly restricting conditions. */ 1839 resume_ptid = user_visible_resume_ptid (step); 1840 1841 /* Maybe resume a single thread after all. */ 1842 if (singlestep_breakpoints_inserted_p 1843 && stepping_past_singlestep_breakpoint) 1844 { 1845 /* The situation here is as follows. In thread T1 we wanted to 1846 single-step. Lacking hardware single-stepping we've 1847 set breakpoint at the PC of the next instruction -- call it 1848 P. After resuming, we've hit that breakpoint in thread T2. 1849 Now we've removed original breakpoint, inserted breakpoint 1850 at P+1, and try to step to advance T2 past breakpoint. 1851 We need to step only T2, as if T1 is allowed to freely run, 1852 it can run past P, and if other threads are allowed to run, 1853 they can hit breakpoint at P+1, and nested hits of single-step 1854 breakpoints is not something we'd want -- that's complicated 1855 to support, and has no value. */ 1856 resume_ptid = inferior_ptid; 1857 } 1858 else if ((step || singlestep_breakpoints_inserted_p) 1859 && tp->control.trap_expected) 1860 { 1861 /* We're allowing a thread to run past a breakpoint it has 1862 hit, by single-stepping the thread with the breakpoint 1863 removed. In which case, we need to single-step only this 1864 thread, and keep others stopped, as they can miss this 1865 breakpoint if allowed to run. 1866 1867 The current code actually removes all breakpoints when 1868 doing this, not just the one being stepped over, so if we 1869 let other threads run, we can actually miss any 1870 breakpoint, not just the one at PC. */ 1871 resume_ptid = inferior_ptid; 1872 } 1873 1874 if (gdbarch_cannot_step_breakpoint (gdbarch)) 1875 { 1876 /* Most targets can step a breakpoint instruction, thus 1877 executing it normally. But if this one cannot, just 1878 continue and we will hit it anyway. */ 1879 if (step && breakpoint_inserted_here_p (aspace, pc)) 1880 step = 0; 1881 } 1882 1883 if (debug_displaced 1884 && use_displaced_stepping (gdbarch) 1885 && tp->control.trap_expected) 1886 { 1887 struct regcache *resume_regcache = get_thread_regcache (resume_ptid); 1888 struct gdbarch *resume_gdbarch = get_regcache_arch (resume_regcache); 1889 CORE_ADDR actual_pc = regcache_read_pc (resume_regcache); 1890 gdb_byte buf[4]; 1891 1892 fprintf_unfiltered (gdb_stdlog, "displaced: run %s: ", 1893 paddress (resume_gdbarch, actual_pc)); 1894 read_memory (actual_pc, buf, sizeof (buf)); 1895 displaced_step_dump_bytes (gdb_stdlog, buf, sizeof (buf)); 1896 } 1897 1898 /* Install inferior's terminal modes. */ 1899 target_terminal_inferior (); 1900 1901 /* Avoid confusing the next resume, if the next stop/resume 1902 happens to apply to another thread. */ 1903 tp->suspend.stop_signal = TARGET_SIGNAL_0; 1904 1905 /* Advise target which signals may be handled silently. If we have 1906 removed breakpoints because we are stepping over one (which can 1907 happen only if we are not using displaced stepping), we need to 1908 receive all signals to avoid accidentally skipping a breakpoint 1909 during execution of a signal handler. */ 1910 if ((step || singlestep_breakpoints_inserted_p) 1911 && tp->control.trap_expected 1912 && !use_displaced_stepping (gdbarch)) 1913 target_pass_signals (0, NULL); 1914 else 1915 target_pass_signals ((int) TARGET_SIGNAL_LAST, signal_pass); 1916 1917 target_resume (resume_ptid, step, sig); 1918 } 1919 1920 discard_cleanups (old_cleanups); 1921 } 1922 1923 /* Proceeding. */ 1924 1925 /* Clear out all variables saying what to do when inferior is continued. 1926 First do this, then set the ones you want, then call `proceed'. */ 1927 1928 static void 1929 clear_proceed_status_thread (struct thread_info *tp) 1930 { 1931 if (debug_infrun) 1932 fprintf_unfiltered (gdb_stdlog, 1933 "infrun: clear_proceed_status_thread (%s)\n", 1934 target_pid_to_str (tp->ptid)); 1935 1936 tp->control.trap_expected = 0; 1937 tp->control.step_range_start = 0; 1938 tp->control.step_range_end = 0; 1939 tp->control.step_frame_id = null_frame_id; 1940 tp->control.step_stack_frame_id = null_frame_id; 1941 tp->control.step_over_calls = STEP_OVER_UNDEBUGGABLE; 1942 tp->stop_requested = 0; 1943 1944 tp->control.stop_step = 0; 1945 1946 tp->control.proceed_to_finish = 0; 1947 1948 /* Discard any remaining commands or status from previous stop. */ 1949 bpstat_clear (&tp->control.stop_bpstat); 1950 } 1951 1952 static int 1953 clear_proceed_status_callback (struct thread_info *tp, void *data) 1954 { 1955 if (is_exited (tp->ptid)) 1956 return 0; 1957 1958 clear_proceed_status_thread (tp); 1959 return 0; 1960 } 1961 1962 void 1963 clear_proceed_status (void) 1964 { 1965 if (!non_stop) 1966 { 1967 /* In all-stop mode, delete the per-thread status of all 1968 threads, even if inferior_ptid is null_ptid, there may be 1969 threads on the list. E.g., we may be launching a new 1970 process, while selecting the executable. */ 1971 iterate_over_threads (clear_proceed_status_callback, NULL); 1972 } 1973 1974 if (!ptid_equal (inferior_ptid, null_ptid)) 1975 { 1976 struct inferior *inferior; 1977 1978 if (non_stop) 1979 { 1980 /* If in non-stop mode, only delete the per-thread status of 1981 the current thread. */ 1982 clear_proceed_status_thread (inferior_thread ()); 1983 } 1984 1985 inferior = current_inferior (); 1986 inferior->control.stop_soon = NO_STOP_QUIETLY; 1987 } 1988 1989 stop_after_trap = 0; 1990 1991 observer_notify_about_to_proceed (); 1992 1993 if (stop_registers) 1994 { 1995 regcache_xfree (stop_registers); 1996 stop_registers = NULL; 1997 } 1998 } 1999 2000 /* Check the current thread against the thread that reported the most recent 2001 event. If a step-over is required return TRUE and set the current thread 2002 to the old thread. Otherwise return FALSE. 2003 2004 This should be suitable for any targets that support threads. */ 2005 2006 static int 2007 prepare_to_proceed (int step) 2008 { 2009 ptid_t wait_ptid; 2010 struct target_waitstatus wait_status; 2011 int schedlock_enabled; 2012 2013 /* With non-stop mode on, threads are always handled individually. */ 2014 gdb_assert (! non_stop); 2015 2016 /* Get the last target status returned by target_wait(). */ 2017 get_last_target_status (&wait_ptid, &wait_status); 2018 2019 /* Make sure we were stopped at a breakpoint. */ 2020 if (wait_status.kind != TARGET_WAITKIND_STOPPED 2021 || (wait_status.value.sig != TARGET_SIGNAL_TRAP 2022 && wait_status.value.sig != TARGET_SIGNAL_ILL 2023 && wait_status.value.sig != TARGET_SIGNAL_SEGV 2024 && wait_status.value.sig != TARGET_SIGNAL_EMT)) 2025 { 2026 return 0; 2027 } 2028 2029 schedlock_enabled = (scheduler_mode == schedlock_on 2030 || (scheduler_mode == schedlock_step 2031 && step)); 2032 2033 /* Don't switch over to WAIT_PTID if scheduler locking is on. */ 2034 if (schedlock_enabled) 2035 return 0; 2036 2037 /* Don't switch over if we're about to resume some other process 2038 other than WAIT_PTID's, and schedule-multiple is off. */ 2039 if (!sched_multi 2040 && ptid_get_pid (wait_ptid) != ptid_get_pid (inferior_ptid)) 2041 return 0; 2042 2043 /* Switched over from WAIT_PID. */ 2044 if (!ptid_equal (wait_ptid, minus_one_ptid) 2045 && !ptid_equal (inferior_ptid, wait_ptid)) 2046 { 2047 struct regcache *regcache = get_thread_regcache (wait_ptid); 2048 2049 if (breakpoint_here_p (get_regcache_aspace (regcache), 2050 regcache_read_pc (regcache))) 2051 { 2052 /* If stepping, remember current thread to switch back to. */ 2053 if (step) 2054 deferred_step_ptid = inferior_ptid; 2055 2056 /* Switch back to WAIT_PID thread. */ 2057 switch_to_thread (wait_ptid); 2058 2059 if (debug_infrun) 2060 fprintf_unfiltered (gdb_stdlog, 2061 "infrun: prepare_to_proceed (step=%d), " 2062 "switched to [%s]\n", 2063 step, target_pid_to_str (inferior_ptid)); 2064 2065 /* We return 1 to indicate that there is a breakpoint here, 2066 so we need to step over it before continuing to avoid 2067 hitting it straight away. */ 2068 return 1; 2069 } 2070 } 2071 2072 return 0; 2073 } 2074 2075 /* Basic routine for continuing the program in various fashions. 2076 2077 ADDR is the address to resume at, or -1 for resume where stopped. 2078 SIGGNAL is the signal to give it, or 0 for none, 2079 or -1 for act according to how it stopped. 2080 STEP is nonzero if should trap after one instruction. 2081 -1 means return after that and print nothing. 2082 You should probably set various step_... variables 2083 before calling here, if you are stepping. 2084 2085 You should call clear_proceed_status before calling proceed. */ 2086 2087 void 2088 proceed (CORE_ADDR addr, enum target_signal siggnal, int step) 2089 { 2090 struct regcache *regcache; 2091 struct gdbarch *gdbarch; 2092 struct thread_info *tp; 2093 CORE_ADDR pc; 2094 struct address_space *aspace; 2095 int oneproc = 0; 2096 2097 /* If we're stopped at a fork/vfork, follow the branch set by the 2098 "set follow-fork-mode" command; otherwise, we'll just proceed 2099 resuming the current thread. */ 2100 if (!follow_fork ()) 2101 { 2102 /* The target for some reason decided not to resume. */ 2103 normal_stop (); 2104 if (target_can_async_p ()) 2105 inferior_event_handler (INF_EXEC_COMPLETE, NULL); 2106 return; 2107 } 2108 2109 /* We'll update this if & when we switch to a new thread. */ 2110 previous_inferior_ptid = inferior_ptid; 2111 2112 regcache = get_current_regcache (); 2113 gdbarch = get_regcache_arch (regcache); 2114 aspace = get_regcache_aspace (regcache); 2115 pc = regcache_read_pc (regcache); 2116 2117 if (step > 0) 2118 step_start_function = find_pc_function (pc); 2119 if (step < 0) 2120 stop_after_trap = 1; 2121 2122 if (addr == (CORE_ADDR) -1) 2123 { 2124 if (pc == stop_pc && breakpoint_here_p (aspace, pc) 2125 && execution_direction != EXEC_REVERSE) 2126 /* There is a breakpoint at the address we will resume at, 2127 step one instruction before inserting breakpoints so that 2128 we do not stop right away (and report a second hit at this 2129 breakpoint). 2130 2131 Note, we don't do this in reverse, because we won't 2132 actually be executing the breakpoint insn anyway. 2133 We'll be (un-)executing the previous instruction. */ 2134 2135 oneproc = 1; 2136 else if (gdbarch_single_step_through_delay_p (gdbarch) 2137 && gdbarch_single_step_through_delay (gdbarch, 2138 get_current_frame ())) 2139 /* We stepped onto an instruction that needs to be stepped 2140 again before re-inserting the breakpoint, do so. */ 2141 oneproc = 1; 2142 } 2143 else 2144 { 2145 regcache_write_pc (regcache, addr); 2146 } 2147 2148 if (debug_infrun) 2149 fprintf_unfiltered (gdb_stdlog, 2150 "infrun: proceed (addr=%s, signal=%d, step=%d)\n", 2151 paddress (gdbarch, addr), siggnal, step); 2152 2153 if (non_stop) 2154 /* In non-stop, each thread is handled individually. The context 2155 must already be set to the right thread here. */ 2156 ; 2157 else 2158 { 2159 /* In a multi-threaded task we may select another thread and 2160 then continue or step. 2161 2162 But if the old thread was stopped at a breakpoint, it will 2163 immediately cause another breakpoint stop without any 2164 execution (i.e. it will report a breakpoint hit incorrectly). 2165 So we must step over it first. 2166 2167 prepare_to_proceed checks the current thread against the 2168 thread that reported the most recent event. If a step-over 2169 is required it returns TRUE and sets the current thread to 2170 the old thread. */ 2171 if (prepare_to_proceed (step)) 2172 oneproc = 1; 2173 } 2174 2175 /* prepare_to_proceed may change the current thread. */ 2176 tp = inferior_thread (); 2177 2178 if (oneproc) 2179 { 2180 tp->control.trap_expected = 1; 2181 /* If displaced stepping is enabled, we can step over the 2182 breakpoint without hitting it, so leave all breakpoints 2183 inserted. Otherwise we need to disable all breakpoints, step 2184 one instruction, and then re-add them when that step is 2185 finished. */ 2186 if (!use_displaced_stepping (gdbarch)) 2187 remove_breakpoints (); 2188 } 2189 2190 /* We can insert breakpoints if we're not trying to step over one, 2191 or if we are stepping over one but we're using displaced stepping 2192 to do so. */ 2193 if (! tp->control.trap_expected || use_displaced_stepping (gdbarch)) 2194 insert_breakpoints (); 2195 2196 if (!non_stop) 2197 { 2198 /* Pass the last stop signal to the thread we're resuming, 2199 irrespective of whether the current thread is the thread that 2200 got the last event or not. This was historically GDB's 2201 behaviour before keeping a stop_signal per thread. */ 2202 2203 struct thread_info *last_thread; 2204 ptid_t last_ptid; 2205 struct target_waitstatus last_status; 2206 2207 get_last_target_status (&last_ptid, &last_status); 2208 if (!ptid_equal (inferior_ptid, last_ptid) 2209 && !ptid_equal (last_ptid, null_ptid) 2210 && !ptid_equal (last_ptid, minus_one_ptid)) 2211 { 2212 last_thread = find_thread_ptid (last_ptid); 2213 if (last_thread) 2214 { 2215 tp->suspend.stop_signal = last_thread->suspend.stop_signal; 2216 last_thread->suspend.stop_signal = TARGET_SIGNAL_0; 2217 } 2218 } 2219 } 2220 2221 if (siggnal != TARGET_SIGNAL_DEFAULT) 2222 tp->suspend.stop_signal = siggnal; 2223 /* If this signal should not be seen by program, 2224 give it zero. Used for debugging signals. */ 2225 else if (!signal_program[tp->suspend.stop_signal]) 2226 tp->suspend.stop_signal = TARGET_SIGNAL_0; 2227 2228 annotate_starting (); 2229 2230 /* Make sure that output from GDB appears before output from the 2231 inferior. */ 2232 gdb_flush (gdb_stdout); 2233 2234 /* Refresh prev_pc value just prior to resuming. This used to be 2235 done in stop_stepping, however, setting prev_pc there did not handle 2236 scenarios such as inferior function calls or returning from 2237 a function via the return command. In those cases, the prev_pc 2238 value was not set properly for subsequent commands. The prev_pc value 2239 is used to initialize the starting line number in the ecs. With an 2240 invalid value, the gdb next command ends up stopping at the position 2241 represented by the next line table entry past our start position. 2242 On platforms that generate one line table entry per line, this 2243 is not a problem. However, on the ia64, the compiler generates 2244 extraneous line table entries that do not increase the line number. 2245 When we issue the gdb next command on the ia64 after an inferior call 2246 or a return command, we often end up a few instructions forward, still 2247 within the original line we started. 2248 2249 An attempt was made to refresh the prev_pc at the same time the 2250 execution_control_state is initialized (for instance, just before 2251 waiting for an inferior event). But this approach did not work 2252 because of platforms that use ptrace, where the pc register cannot 2253 be read unless the inferior is stopped. At that point, we are not 2254 guaranteed the inferior is stopped and so the regcache_read_pc() call 2255 can fail. Setting the prev_pc value here ensures the value is updated 2256 correctly when the inferior is stopped. */ 2257 tp->prev_pc = regcache_read_pc (get_current_regcache ()); 2258 2259 /* Fill in with reasonable starting values. */ 2260 init_thread_stepping_state (tp); 2261 2262 /* Reset to normal state. */ 2263 init_infwait_state (); 2264 2265 /* Resume inferior. */ 2266 resume (oneproc || step || bpstat_should_step (), tp->suspend.stop_signal); 2267 2268 /* Wait for it to stop (if not standalone) 2269 and in any case decode why it stopped, and act accordingly. */ 2270 /* Do this only if we are not using the event loop, or if the target 2271 does not support asynchronous execution. */ 2272 if (!target_can_async_p ()) 2273 { 2274 wait_for_inferior (); 2275 normal_stop (); 2276 } 2277 } 2278 2279 2280 /* Start remote-debugging of a machine over a serial link. */ 2281 2282 void 2283 start_remote (int from_tty) 2284 { 2285 struct inferior *inferior; 2286 2287 inferior = current_inferior (); 2288 inferior->control.stop_soon = STOP_QUIETLY_REMOTE; 2289 2290 /* Always go on waiting for the target, regardless of the mode. */ 2291 /* FIXME: cagney/1999-09-23: At present it isn't possible to 2292 indicate to wait_for_inferior that a target should timeout if 2293 nothing is returned (instead of just blocking). Because of this, 2294 targets expecting an immediate response need to, internally, set 2295 things up so that the target_wait() is forced to eventually 2296 timeout. */ 2297 /* FIXME: cagney/1999-09-24: It isn't possible for target_open() to 2298 differentiate to its caller what the state of the target is after 2299 the initial open has been performed. Here we're assuming that 2300 the target has stopped. It should be possible to eventually have 2301 target_open() return to the caller an indication that the target 2302 is currently running and GDB state should be set to the same as 2303 for an async run. */ 2304 wait_for_inferior (); 2305 2306 /* Now that the inferior has stopped, do any bookkeeping like 2307 loading shared libraries. We want to do this before normal_stop, 2308 so that the displayed frame is up to date. */ 2309 post_create_inferior (¤t_target, from_tty); 2310 2311 normal_stop (); 2312 } 2313 2314 /* Initialize static vars when a new inferior begins. */ 2315 2316 void 2317 init_wait_for_inferior (void) 2318 { 2319 /* These are meaningless until the first time through wait_for_inferior. */ 2320 2321 breakpoint_init_inferior (inf_starting); 2322 2323 clear_proceed_status (); 2324 2325 stepping_past_singlestep_breakpoint = 0; 2326 deferred_step_ptid = null_ptid; 2327 2328 target_last_wait_ptid = minus_one_ptid; 2329 2330 previous_inferior_ptid = inferior_ptid; 2331 init_infwait_state (); 2332 2333 /* Discard any skipped inlined frames. */ 2334 clear_inline_frame_state (minus_one_ptid); 2335 } 2336 2337 2338 /* This enum encodes possible reasons for doing a target_wait, so that 2339 wfi can call target_wait in one place. (Ultimately the call will be 2340 moved out of the infinite loop entirely.) */ 2341 2342 enum infwait_states 2343 { 2344 infwait_normal_state, 2345 infwait_thread_hop_state, 2346 infwait_step_watch_state, 2347 infwait_nonstep_watch_state 2348 }; 2349 2350 /* The PTID we'll do a target_wait on.*/ 2351 ptid_t waiton_ptid; 2352 2353 /* Current inferior wait state. */ 2354 enum infwait_states infwait_state; 2355 2356 /* Data to be passed around while handling an event. This data is 2357 discarded between events. */ 2358 struct execution_control_state 2359 { 2360 ptid_t ptid; 2361 /* The thread that got the event, if this was a thread event; NULL 2362 otherwise. */ 2363 struct thread_info *event_thread; 2364 2365 struct target_waitstatus ws; 2366 int random_signal; 2367 int stop_func_filled_in; 2368 CORE_ADDR stop_func_start; 2369 CORE_ADDR stop_func_end; 2370 char *stop_func_name; 2371 int new_thread_event; 2372 int wait_some_more; 2373 }; 2374 2375 static void handle_inferior_event (struct execution_control_state *ecs); 2376 2377 static void handle_step_into_function (struct gdbarch *gdbarch, 2378 struct execution_control_state *ecs); 2379 static void handle_step_into_function_backward (struct gdbarch *gdbarch, 2380 struct execution_control_state *ecs); 2381 static void check_exception_resume (struct execution_control_state *, 2382 struct frame_info *, struct symbol *); 2383 2384 static void stop_stepping (struct execution_control_state *ecs); 2385 static void prepare_to_wait (struct execution_control_state *ecs); 2386 static void keep_going (struct execution_control_state *ecs); 2387 2388 /* Callback for iterate over threads. If the thread is stopped, but 2389 the user/frontend doesn't know about that yet, go through 2390 normal_stop, as if the thread had just stopped now. ARG points at 2391 a ptid. If PTID is MINUS_ONE_PTID, applies to all threads. If 2392 ptid_is_pid(PTID) is true, applies to all threads of the process 2393 pointed at by PTID. Otherwise, apply only to the thread pointed by 2394 PTID. */ 2395 2396 static int 2397 infrun_thread_stop_requested_callback (struct thread_info *info, void *arg) 2398 { 2399 ptid_t ptid = * (ptid_t *) arg; 2400 2401 if ((ptid_equal (info->ptid, ptid) 2402 || ptid_equal (minus_one_ptid, ptid) 2403 || (ptid_is_pid (ptid) 2404 && ptid_get_pid (ptid) == ptid_get_pid (info->ptid))) 2405 && is_running (info->ptid) 2406 && !is_executing (info->ptid)) 2407 { 2408 struct cleanup *old_chain; 2409 struct execution_control_state ecss; 2410 struct execution_control_state *ecs = &ecss; 2411 2412 memset (ecs, 0, sizeof (*ecs)); 2413 2414 old_chain = make_cleanup_restore_current_thread (); 2415 2416 switch_to_thread (info->ptid); 2417 2418 /* Go through handle_inferior_event/normal_stop, so we always 2419 have consistent output as if the stop event had been 2420 reported. */ 2421 ecs->ptid = info->ptid; 2422 ecs->event_thread = find_thread_ptid (info->ptid); 2423 ecs->ws.kind = TARGET_WAITKIND_STOPPED; 2424 ecs->ws.value.sig = TARGET_SIGNAL_0; 2425 2426 handle_inferior_event (ecs); 2427 2428 if (!ecs->wait_some_more) 2429 { 2430 struct thread_info *tp; 2431 2432 normal_stop (); 2433 2434 /* Finish off the continuations. */ 2435 tp = inferior_thread (); 2436 do_all_intermediate_continuations_thread (tp, 1); 2437 do_all_continuations_thread (tp, 1); 2438 } 2439 2440 do_cleanups (old_chain); 2441 } 2442 2443 return 0; 2444 } 2445 2446 /* This function is attached as a "thread_stop_requested" observer. 2447 Cleanup local state that assumed the PTID was to be resumed, and 2448 report the stop to the frontend. */ 2449 2450 static void 2451 infrun_thread_stop_requested (ptid_t ptid) 2452 { 2453 struct displaced_step_inferior_state *displaced; 2454 2455 /* PTID was requested to stop. Remove it from the displaced 2456 stepping queue, so we don't try to resume it automatically. */ 2457 2458 for (displaced = displaced_step_inferior_states; 2459 displaced; 2460 displaced = displaced->next) 2461 { 2462 struct displaced_step_request *it, **prev_next_p; 2463 2464 it = displaced->step_request_queue; 2465 prev_next_p = &displaced->step_request_queue; 2466 while (it) 2467 { 2468 if (ptid_match (it->ptid, ptid)) 2469 { 2470 *prev_next_p = it->next; 2471 it->next = NULL; 2472 xfree (it); 2473 } 2474 else 2475 { 2476 prev_next_p = &it->next; 2477 } 2478 2479 it = *prev_next_p; 2480 } 2481 } 2482 2483 iterate_over_threads (infrun_thread_stop_requested_callback, &ptid); 2484 } 2485 2486 static void 2487 infrun_thread_thread_exit (struct thread_info *tp, int silent) 2488 { 2489 if (ptid_equal (target_last_wait_ptid, tp->ptid)) 2490 nullify_last_target_wait_ptid (); 2491 } 2492 2493 /* Callback for iterate_over_threads. */ 2494 2495 static int 2496 delete_step_resume_breakpoint_callback (struct thread_info *info, void *data) 2497 { 2498 if (is_exited (info->ptid)) 2499 return 0; 2500 2501 delete_step_resume_breakpoint (info); 2502 delete_exception_resume_breakpoint (info); 2503 return 0; 2504 } 2505 2506 /* In all-stop, delete the step resume breakpoint of any thread that 2507 had one. In non-stop, delete the step resume breakpoint of the 2508 thread that just stopped. */ 2509 2510 static void 2511 delete_step_thread_step_resume_breakpoint (void) 2512 { 2513 if (!target_has_execution 2514 || ptid_equal (inferior_ptid, null_ptid)) 2515 /* If the inferior has exited, we have already deleted the step 2516 resume breakpoints out of GDB's lists. */ 2517 return; 2518 2519 if (non_stop) 2520 { 2521 /* If in non-stop mode, only delete the step-resume or 2522 longjmp-resume breakpoint of the thread that just stopped 2523 stepping. */ 2524 struct thread_info *tp = inferior_thread (); 2525 2526 delete_step_resume_breakpoint (tp); 2527 delete_exception_resume_breakpoint (tp); 2528 } 2529 else 2530 /* In all-stop mode, delete all step-resume and longjmp-resume 2531 breakpoints of any thread that had them. */ 2532 iterate_over_threads (delete_step_resume_breakpoint_callback, NULL); 2533 } 2534 2535 /* A cleanup wrapper. */ 2536 2537 static void 2538 delete_step_thread_step_resume_breakpoint_cleanup (void *arg) 2539 { 2540 delete_step_thread_step_resume_breakpoint (); 2541 } 2542 2543 /* Pretty print the results of target_wait, for debugging purposes. */ 2544 2545 static void 2546 print_target_wait_results (ptid_t waiton_ptid, ptid_t result_ptid, 2547 const struct target_waitstatus *ws) 2548 { 2549 char *status_string = target_waitstatus_to_string (ws); 2550 struct ui_file *tmp_stream = mem_fileopen (); 2551 char *text; 2552 2553 /* The text is split over several lines because it was getting too long. 2554 Call fprintf_unfiltered (gdb_stdlog) once so that the text is still 2555 output as a unit; we want only one timestamp printed if debug_timestamp 2556 is set. */ 2557 2558 fprintf_unfiltered (tmp_stream, 2559 "infrun: target_wait (%d", PIDGET (waiton_ptid)); 2560 if (PIDGET (waiton_ptid) != -1) 2561 fprintf_unfiltered (tmp_stream, 2562 " [%s]", target_pid_to_str (waiton_ptid)); 2563 fprintf_unfiltered (tmp_stream, ", status) =\n"); 2564 fprintf_unfiltered (tmp_stream, 2565 "infrun: %d [%s],\n", 2566 PIDGET (result_ptid), target_pid_to_str (result_ptid)); 2567 fprintf_unfiltered (tmp_stream, 2568 "infrun: %s\n", 2569 status_string); 2570 2571 text = ui_file_xstrdup (tmp_stream, NULL); 2572 2573 /* This uses %s in part to handle %'s in the text, but also to avoid 2574 a gcc error: the format attribute requires a string literal. */ 2575 fprintf_unfiltered (gdb_stdlog, "%s", text); 2576 2577 xfree (status_string); 2578 xfree (text); 2579 ui_file_delete (tmp_stream); 2580 } 2581 2582 /* Prepare and stabilize the inferior for detaching it. E.g., 2583 detaching while a thread is displaced stepping is a recipe for 2584 crashing it, as nothing would readjust the PC out of the scratch 2585 pad. */ 2586 2587 void 2588 prepare_for_detach (void) 2589 { 2590 struct inferior *inf = current_inferior (); 2591 ptid_t pid_ptid = pid_to_ptid (inf->pid); 2592 struct cleanup *old_chain_1; 2593 struct displaced_step_inferior_state *displaced; 2594 2595 displaced = get_displaced_stepping_state (inf->pid); 2596 2597 /* Is any thread of this process displaced stepping? If not, 2598 there's nothing else to do. */ 2599 if (displaced == NULL || ptid_equal (displaced->step_ptid, null_ptid)) 2600 return; 2601 2602 if (debug_infrun) 2603 fprintf_unfiltered (gdb_stdlog, 2604 "displaced-stepping in-process while detaching"); 2605 2606 old_chain_1 = make_cleanup_restore_integer (&inf->detaching); 2607 inf->detaching = 1; 2608 2609 while (!ptid_equal (displaced->step_ptid, null_ptid)) 2610 { 2611 struct cleanup *old_chain_2; 2612 struct execution_control_state ecss; 2613 struct execution_control_state *ecs; 2614 2615 ecs = &ecss; 2616 memset (ecs, 0, sizeof (*ecs)); 2617 2618 overlay_cache_invalid = 1; 2619 2620 if (deprecated_target_wait_hook) 2621 ecs->ptid = deprecated_target_wait_hook (pid_ptid, &ecs->ws, 0); 2622 else 2623 ecs->ptid = target_wait (pid_ptid, &ecs->ws, 0); 2624 2625 if (debug_infrun) 2626 print_target_wait_results (pid_ptid, ecs->ptid, &ecs->ws); 2627 2628 /* If an error happens while handling the event, propagate GDB's 2629 knowledge of the executing state to the frontend/user running 2630 state. */ 2631 old_chain_2 = make_cleanup (finish_thread_state_cleanup, 2632 &minus_one_ptid); 2633 2634 /* In non-stop mode, each thread is handled individually. 2635 Switch early, so the global state is set correctly for this 2636 thread. */ 2637 if (non_stop 2638 && ecs->ws.kind != TARGET_WAITKIND_EXITED 2639 && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED) 2640 context_switch (ecs->ptid); 2641 2642 /* Now figure out what to do with the result of the result. */ 2643 handle_inferior_event (ecs); 2644 2645 /* No error, don't finish the state yet. */ 2646 discard_cleanups (old_chain_2); 2647 2648 /* Breakpoints and watchpoints are not installed on the target 2649 at this point, and signals are passed directly to the 2650 inferior, so this must mean the process is gone. */ 2651 if (!ecs->wait_some_more) 2652 { 2653 discard_cleanups (old_chain_1); 2654 error (_("Program exited while detaching")); 2655 } 2656 } 2657 2658 discard_cleanups (old_chain_1); 2659 } 2660 2661 /* Wait for control to return from inferior to debugger. 2662 2663 If inferior gets a signal, we may decide to start it up again 2664 instead of returning. That is why there is a loop in this function. 2665 When this function actually returns it means the inferior 2666 should be left stopped and GDB should read more commands. */ 2667 2668 void 2669 wait_for_inferior (void) 2670 { 2671 struct cleanup *old_cleanups; 2672 struct execution_control_state ecss; 2673 struct execution_control_state *ecs; 2674 2675 if (debug_infrun) 2676 fprintf_unfiltered 2677 (gdb_stdlog, "infrun: wait_for_inferior ()\n"); 2678 2679 old_cleanups = 2680 make_cleanup (delete_step_thread_step_resume_breakpoint_cleanup, NULL); 2681 2682 ecs = &ecss; 2683 memset (ecs, 0, sizeof (*ecs)); 2684 2685 while (1) 2686 { 2687 struct cleanup *old_chain; 2688 2689 overlay_cache_invalid = 1; 2690 2691 if (deprecated_target_wait_hook) 2692 ecs->ptid = deprecated_target_wait_hook (waiton_ptid, &ecs->ws, 0); 2693 else 2694 ecs->ptid = target_wait (waiton_ptid, &ecs->ws, 0); 2695 2696 if (debug_infrun) 2697 print_target_wait_results (waiton_ptid, ecs->ptid, &ecs->ws); 2698 2699 /* If an error happens while handling the event, propagate GDB's 2700 knowledge of the executing state to the frontend/user running 2701 state. */ 2702 old_chain = make_cleanup (finish_thread_state_cleanup, &minus_one_ptid); 2703 2704 if (ecs->ws.kind == TARGET_WAITKIND_SYSCALL_ENTRY 2705 || ecs->ws.kind == TARGET_WAITKIND_SYSCALL_RETURN) 2706 ecs->ws.value.syscall_number = UNKNOWN_SYSCALL; 2707 2708 /* Now figure out what to do with the result of the result. */ 2709 handle_inferior_event (ecs); 2710 2711 /* No error, don't finish the state yet. */ 2712 discard_cleanups (old_chain); 2713 2714 if (!ecs->wait_some_more) 2715 break; 2716 } 2717 2718 do_cleanups (old_cleanups); 2719 } 2720 2721 /* Asynchronous version of wait_for_inferior. It is called by the 2722 event loop whenever a change of state is detected on the file 2723 descriptor corresponding to the target. It can be called more than 2724 once to complete a single execution command. In such cases we need 2725 to keep the state in a global variable ECSS. If it is the last time 2726 that this function is called for a single execution command, then 2727 report to the user that the inferior has stopped, and do the 2728 necessary cleanups. */ 2729 2730 void 2731 fetch_inferior_event (void *client_data) 2732 { 2733 struct execution_control_state ecss; 2734 struct execution_control_state *ecs = &ecss; 2735 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL); 2736 struct cleanup *ts_old_chain; 2737 int was_sync = sync_execution; 2738 int cmd_done = 0; 2739 2740 memset (ecs, 0, sizeof (*ecs)); 2741 2742 /* We're handling a live event, so make sure we're doing live 2743 debugging. If we're looking at traceframes while the target is 2744 running, we're going to need to get back to that mode after 2745 handling the event. */ 2746 if (non_stop) 2747 { 2748 make_cleanup_restore_current_traceframe (); 2749 set_current_traceframe (-1); 2750 } 2751 2752 if (non_stop) 2753 /* In non-stop mode, the user/frontend should not notice a thread 2754 switch due to internal events. Make sure we reverse to the 2755 user selected thread and frame after handling the event and 2756 running any breakpoint commands. */ 2757 make_cleanup_restore_current_thread (); 2758 2759 overlay_cache_invalid = 1; 2760 2761 make_cleanup_restore_integer (&execution_direction); 2762 execution_direction = target_execution_direction (); 2763 2764 if (deprecated_target_wait_hook) 2765 ecs->ptid = 2766 deprecated_target_wait_hook (waiton_ptid, &ecs->ws, TARGET_WNOHANG); 2767 else 2768 ecs->ptid = target_wait (waiton_ptid, &ecs->ws, TARGET_WNOHANG); 2769 2770 if (debug_infrun) 2771 print_target_wait_results (waiton_ptid, ecs->ptid, &ecs->ws); 2772 2773 if (non_stop 2774 && ecs->ws.kind != TARGET_WAITKIND_IGNORE 2775 && ecs->ws.kind != TARGET_WAITKIND_NO_RESUMED 2776 && ecs->ws.kind != TARGET_WAITKIND_EXITED 2777 && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED) 2778 /* In non-stop mode, each thread is handled individually. Switch 2779 early, so the global state is set correctly for this 2780 thread. */ 2781 context_switch (ecs->ptid); 2782 2783 /* If an error happens while handling the event, propagate GDB's 2784 knowledge of the executing state to the frontend/user running 2785 state. */ 2786 if (!non_stop) 2787 ts_old_chain = make_cleanup (finish_thread_state_cleanup, &minus_one_ptid); 2788 else 2789 ts_old_chain = make_cleanup (finish_thread_state_cleanup, &ecs->ptid); 2790 2791 /* Get executed before make_cleanup_restore_current_thread above to apply 2792 still for the thread which has thrown the exception. */ 2793 make_bpstat_clear_actions_cleanup (); 2794 2795 /* Now figure out what to do with the result of the result. */ 2796 handle_inferior_event (ecs); 2797 2798 if (!ecs->wait_some_more) 2799 { 2800 struct inferior *inf = find_inferior_pid (ptid_get_pid (ecs->ptid)); 2801 2802 delete_step_thread_step_resume_breakpoint (); 2803 2804 /* We may not find an inferior if this was a process exit. */ 2805 if (inf == NULL || inf->control.stop_soon == NO_STOP_QUIETLY) 2806 normal_stop (); 2807 2808 if (target_has_execution 2809 && ecs->ws.kind != TARGET_WAITKIND_NO_RESUMED 2810 && ecs->ws.kind != TARGET_WAITKIND_EXITED 2811 && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED 2812 && ecs->event_thread->step_multi 2813 && ecs->event_thread->control.stop_step) 2814 inferior_event_handler (INF_EXEC_CONTINUE, NULL); 2815 else 2816 { 2817 inferior_event_handler (INF_EXEC_COMPLETE, NULL); 2818 cmd_done = 1; 2819 } 2820 } 2821 2822 /* No error, don't finish the thread states yet. */ 2823 discard_cleanups (ts_old_chain); 2824 2825 /* Revert thread and frame. */ 2826 do_cleanups (old_chain); 2827 2828 /* If the inferior was in sync execution mode, and now isn't, 2829 restore the prompt (a synchronous execution command has finished, 2830 and we're ready for input). */ 2831 if (interpreter_async && was_sync && !sync_execution) 2832 display_gdb_prompt (0); 2833 2834 if (cmd_done 2835 && !was_sync 2836 && exec_done_display_p 2837 && (ptid_equal (inferior_ptid, null_ptid) 2838 || !is_running (inferior_ptid))) 2839 printf_unfiltered (_("completed.\n")); 2840 } 2841 2842 /* Record the frame and location we're currently stepping through. */ 2843 void 2844 set_step_info (struct frame_info *frame, struct symtab_and_line sal) 2845 { 2846 struct thread_info *tp = inferior_thread (); 2847 2848 tp->control.step_frame_id = get_frame_id (frame); 2849 tp->control.step_stack_frame_id = get_stack_frame_id (frame); 2850 2851 tp->current_symtab = sal.symtab; 2852 tp->current_line = sal.line; 2853 } 2854 2855 /* Clear context switchable stepping state. */ 2856 2857 void 2858 init_thread_stepping_state (struct thread_info *tss) 2859 { 2860 tss->stepping_over_breakpoint = 0; 2861 tss->step_after_step_resume_breakpoint = 0; 2862 } 2863 2864 /* Return the cached copy of the last pid/waitstatus returned by 2865 target_wait()/deprecated_target_wait_hook(). The data is actually 2866 cached by handle_inferior_event(), which gets called immediately 2867 after target_wait()/deprecated_target_wait_hook(). */ 2868 2869 void 2870 get_last_target_status (ptid_t *ptidp, struct target_waitstatus *status) 2871 { 2872 *ptidp = target_last_wait_ptid; 2873 *status = target_last_waitstatus; 2874 } 2875 2876 void 2877 nullify_last_target_wait_ptid (void) 2878 { 2879 target_last_wait_ptid = minus_one_ptid; 2880 } 2881 2882 /* Switch thread contexts. */ 2883 2884 static void 2885 context_switch (ptid_t ptid) 2886 { 2887 if (debug_infrun && !ptid_equal (ptid, inferior_ptid)) 2888 { 2889 fprintf_unfiltered (gdb_stdlog, "infrun: Switching context from %s ", 2890 target_pid_to_str (inferior_ptid)); 2891 fprintf_unfiltered (gdb_stdlog, "to %s\n", 2892 target_pid_to_str (ptid)); 2893 } 2894 2895 switch_to_thread (ptid); 2896 } 2897 2898 static void 2899 adjust_pc_after_break (struct execution_control_state *ecs) 2900 { 2901 struct regcache *regcache; 2902 struct gdbarch *gdbarch; 2903 struct address_space *aspace; 2904 CORE_ADDR breakpoint_pc; 2905 2906 /* If we've hit a breakpoint, we'll normally be stopped with SIGTRAP. If 2907 we aren't, just return. 2908 2909 We assume that waitkinds other than TARGET_WAITKIND_STOPPED are not 2910 affected by gdbarch_decr_pc_after_break. Other waitkinds which are 2911 implemented by software breakpoints should be handled through the normal 2912 breakpoint layer. 2913 2914 NOTE drow/2004-01-31: On some targets, breakpoints may generate 2915 different signals (SIGILL or SIGEMT for instance), but it is less 2916 clear where the PC is pointing afterwards. It may not match 2917 gdbarch_decr_pc_after_break. I don't know any specific target that 2918 generates these signals at breakpoints (the code has been in GDB since at 2919 least 1992) so I can not guess how to handle them here. 2920 2921 In earlier versions of GDB, a target with 2922 gdbarch_have_nonsteppable_watchpoint would have the PC after hitting a 2923 watchpoint affected by gdbarch_decr_pc_after_break. I haven't found any 2924 target with both of these set in GDB history, and it seems unlikely to be 2925 correct, so gdbarch_have_nonsteppable_watchpoint is not checked here. */ 2926 2927 if (ecs->ws.kind != TARGET_WAITKIND_STOPPED) 2928 return; 2929 2930 if (ecs->ws.value.sig != TARGET_SIGNAL_TRAP) 2931 return; 2932 2933 /* In reverse execution, when a breakpoint is hit, the instruction 2934 under it has already been de-executed. The reported PC always 2935 points at the breakpoint address, so adjusting it further would 2936 be wrong. E.g., consider this case on a decr_pc_after_break == 1 2937 architecture: 2938 2939 B1 0x08000000 : INSN1 2940 B2 0x08000001 : INSN2 2941 0x08000002 : INSN3 2942 PC -> 0x08000003 : INSN4 2943 2944 Say you're stopped at 0x08000003 as above. Reverse continuing 2945 from that point should hit B2 as below. Reading the PC when the 2946 SIGTRAP is reported should read 0x08000001 and INSN2 should have 2947 been de-executed already. 2948 2949 B1 0x08000000 : INSN1 2950 B2 PC -> 0x08000001 : INSN2 2951 0x08000002 : INSN3 2952 0x08000003 : INSN4 2953 2954 We can't apply the same logic as for forward execution, because 2955 we would wrongly adjust the PC to 0x08000000, since there's a 2956 breakpoint at PC - 1. We'd then report a hit on B1, although 2957 INSN1 hadn't been de-executed yet. Doing nothing is the correct 2958 behaviour. */ 2959 if (execution_direction == EXEC_REVERSE) 2960 return; 2961 2962 /* If this target does not decrement the PC after breakpoints, then 2963 we have nothing to do. */ 2964 regcache = get_thread_regcache (ecs->ptid); 2965 gdbarch = get_regcache_arch (regcache); 2966 if (gdbarch_decr_pc_after_break (gdbarch) == 0) 2967 return; 2968 2969 aspace = get_regcache_aspace (regcache); 2970 2971 /* Find the location where (if we've hit a breakpoint) the 2972 breakpoint would be. */ 2973 breakpoint_pc = regcache_read_pc (regcache) 2974 - gdbarch_decr_pc_after_break (gdbarch); 2975 2976 /* Check whether there actually is a software breakpoint inserted at 2977 that location. 2978 2979 If in non-stop mode, a race condition is possible where we've 2980 removed a breakpoint, but stop events for that breakpoint were 2981 already queued and arrive later. To suppress those spurious 2982 SIGTRAPs, we keep a list of such breakpoint locations for a bit, 2983 and retire them after a number of stop events are reported. */ 2984 if (software_breakpoint_inserted_here_p (aspace, breakpoint_pc) 2985 || (non_stop && moribund_breakpoint_here_p (aspace, breakpoint_pc))) 2986 { 2987 struct cleanup *old_cleanups = NULL; 2988 2989 if (RECORD_IS_USED) 2990 old_cleanups = record_gdb_operation_disable_set (); 2991 2992 /* When using hardware single-step, a SIGTRAP is reported for both 2993 a completed single-step and a software breakpoint. Need to 2994 differentiate between the two, as the latter needs adjusting 2995 but the former does not. 2996 2997 The SIGTRAP can be due to a completed hardware single-step only if 2998 - we didn't insert software single-step breakpoints 2999 - the thread to be examined is still the current thread 3000 - this thread is currently being stepped 3001 3002 If any of these events did not occur, we must have stopped due 3003 to hitting a software breakpoint, and have to back up to the 3004 breakpoint address. 3005 3006 As a special case, we could have hardware single-stepped a 3007 software breakpoint. In this case (prev_pc == breakpoint_pc), 3008 we also need to back up to the breakpoint address. */ 3009 3010 if (singlestep_breakpoints_inserted_p 3011 || !ptid_equal (ecs->ptid, inferior_ptid) 3012 || !currently_stepping (ecs->event_thread) 3013 || ecs->event_thread->prev_pc == breakpoint_pc) 3014 regcache_write_pc (regcache, breakpoint_pc); 3015 3016 if (RECORD_IS_USED) 3017 do_cleanups (old_cleanups); 3018 } 3019 } 3020 3021 void 3022 init_infwait_state (void) 3023 { 3024 waiton_ptid = pid_to_ptid (-1); 3025 infwait_state = infwait_normal_state; 3026 } 3027 3028 void 3029 error_is_running (void) 3030 { 3031 error (_("Cannot execute this command while " 3032 "the selected thread is running.")); 3033 } 3034 3035 void 3036 ensure_not_running (void) 3037 { 3038 if (is_running (inferior_ptid)) 3039 error_is_running (); 3040 } 3041 3042 static int 3043 stepped_in_from (struct frame_info *frame, struct frame_id step_frame_id) 3044 { 3045 for (frame = get_prev_frame (frame); 3046 frame != NULL; 3047 frame = get_prev_frame (frame)) 3048 { 3049 if (frame_id_eq (get_frame_id (frame), step_frame_id)) 3050 return 1; 3051 if (get_frame_type (frame) != INLINE_FRAME) 3052 break; 3053 } 3054 3055 return 0; 3056 } 3057 3058 /* Auxiliary function that handles syscall entry/return events. 3059 It returns 1 if the inferior should keep going (and GDB 3060 should ignore the event), or 0 if the event deserves to be 3061 processed. */ 3062 3063 static int 3064 handle_syscall_event (struct execution_control_state *ecs) 3065 { 3066 struct regcache *regcache; 3067 struct gdbarch *gdbarch; 3068 int syscall_number; 3069 3070 if (!ptid_equal (ecs->ptid, inferior_ptid)) 3071 context_switch (ecs->ptid); 3072 3073 regcache = get_thread_regcache (ecs->ptid); 3074 gdbarch = get_regcache_arch (regcache); 3075 syscall_number = gdbarch_get_syscall_number (gdbarch, ecs->ptid); 3076 stop_pc = regcache_read_pc (regcache); 3077 3078 target_last_waitstatus.value.syscall_number = syscall_number; 3079 3080 if (catch_syscall_enabled () > 0 3081 && catching_syscall_number (syscall_number) > 0) 3082 { 3083 if (debug_infrun) 3084 fprintf_unfiltered (gdb_stdlog, "infrun: syscall number = '%d'\n", 3085 syscall_number); 3086 3087 ecs->event_thread->control.stop_bpstat 3088 = bpstat_stop_status (get_regcache_aspace (regcache), 3089 stop_pc, ecs->ptid); 3090 ecs->random_signal 3091 = !bpstat_explains_signal (ecs->event_thread->control.stop_bpstat); 3092 3093 if (!ecs->random_signal) 3094 { 3095 /* Catchpoint hit. */ 3096 ecs->event_thread->suspend.stop_signal = TARGET_SIGNAL_TRAP; 3097 return 0; 3098 } 3099 } 3100 3101 /* If no catchpoint triggered for this, then keep going. */ 3102 ecs->event_thread->suspend.stop_signal = TARGET_SIGNAL_0; 3103 keep_going (ecs); 3104 return 1; 3105 } 3106 3107 /* Clear the supplied execution_control_state's stop_func_* fields. */ 3108 3109 static void 3110 clear_stop_func (struct execution_control_state *ecs) 3111 { 3112 ecs->stop_func_filled_in = 0; 3113 ecs->stop_func_start = 0; 3114 ecs->stop_func_end = 0; 3115 ecs->stop_func_name = NULL; 3116 } 3117 3118 /* Lazily fill in the execution_control_state's stop_func_* fields. */ 3119 3120 static void 3121 fill_in_stop_func (struct gdbarch *gdbarch, 3122 struct execution_control_state *ecs) 3123 { 3124 if (!ecs->stop_func_filled_in) 3125 { 3126 /* Don't care about return value; stop_func_start and stop_func_name 3127 will both be 0 if it doesn't work. */ 3128 find_pc_partial_function (stop_pc, &ecs->stop_func_name, 3129 &ecs->stop_func_start, &ecs->stop_func_end); 3130 ecs->stop_func_start 3131 += gdbarch_deprecated_function_start_offset (gdbarch); 3132 3133 ecs->stop_func_filled_in = 1; 3134 } 3135 } 3136 3137 /* Given an execution control state that has been freshly filled in 3138 by an event from the inferior, figure out what it means and take 3139 appropriate action. */ 3140 3141 static void 3142 handle_inferior_event (struct execution_control_state *ecs) 3143 { 3144 struct frame_info *frame; 3145 struct gdbarch *gdbarch; 3146 int stopped_by_watchpoint; 3147 int stepped_after_stopped_by_watchpoint = 0; 3148 struct symtab_and_line stop_pc_sal; 3149 enum stop_kind stop_soon; 3150 3151 if (ecs->ws.kind == TARGET_WAITKIND_IGNORE) 3152 { 3153 /* We had an event in the inferior, but we are not interested in 3154 handling it at this level. The lower layers have already 3155 done what needs to be done, if anything. 3156 3157 One of the possible circumstances for this is when the 3158 inferior produces output for the console. The inferior has 3159 not stopped, and we are ignoring the event. Another possible 3160 circumstance is any event which the lower level knows will be 3161 reported multiple times without an intervening resume. */ 3162 if (debug_infrun) 3163 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_IGNORE\n"); 3164 prepare_to_wait (ecs); 3165 return; 3166 } 3167 3168 if (ecs->ws.kind == TARGET_WAITKIND_NO_RESUMED 3169 && target_can_async_p () && !sync_execution) 3170 { 3171 /* There were no unwaited-for children left in the target, but, 3172 we're not synchronously waiting for events either. Just 3173 ignore. Otherwise, if we were running a synchronous 3174 execution command, we need to cancel it and give the user 3175 back the terminal. */ 3176 if (debug_infrun) 3177 fprintf_unfiltered (gdb_stdlog, 3178 "infrun: TARGET_WAITKIND_NO_RESUMED (ignoring)\n"); 3179 prepare_to_wait (ecs); 3180 return; 3181 } 3182 3183 if (ecs->ws.kind != TARGET_WAITKIND_EXITED 3184 && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED 3185 && ecs->ws.kind != TARGET_WAITKIND_NO_RESUMED) 3186 { 3187 struct inferior *inf = find_inferior_pid (ptid_get_pid (ecs->ptid)); 3188 3189 gdb_assert (inf); 3190 stop_soon = inf->control.stop_soon; 3191 } 3192 else 3193 stop_soon = NO_STOP_QUIETLY; 3194 3195 /* Cache the last pid/waitstatus. */ 3196 target_last_wait_ptid = ecs->ptid; 3197 target_last_waitstatus = ecs->ws; 3198 3199 /* Always clear state belonging to the previous time we stopped. */ 3200 stop_stack_dummy = STOP_NONE; 3201 3202 if (ecs->ws.kind == TARGET_WAITKIND_NO_RESUMED) 3203 { 3204 /* No unwaited-for children left. IOW, all resumed children 3205 have exited. */ 3206 if (debug_infrun) 3207 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_NO_RESUMED\n"); 3208 3209 stop_print_frame = 0; 3210 stop_stepping (ecs); 3211 return; 3212 } 3213 3214 /* If it's a new process, add it to the thread database. */ 3215 3216 ecs->new_thread_event = (!ptid_equal (ecs->ptid, inferior_ptid) 3217 && !ptid_equal (ecs->ptid, minus_one_ptid) 3218 && !in_thread_list (ecs->ptid)); 3219 3220 if (ecs->ws.kind != TARGET_WAITKIND_EXITED 3221 && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED && ecs->new_thread_event) 3222 add_thread (ecs->ptid); 3223 3224 ecs->event_thread = find_thread_ptid (ecs->ptid); 3225 3226 /* Dependent on valid ECS->EVENT_THREAD. */ 3227 adjust_pc_after_break (ecs); 3228 3229 /* Dependent on the current PC value modified by adjust_pc_after_break. */ 3230 reinit_frame_cache (); 3231 3232 breakpoint_retire_moribund (); 3233 3234 /* First, distinguish signals caused by the debugger from signals 3235 that have to do with the program's own actions. Note that 3236 breakpoint insns may cause SIGTRAP or SIGILL or SIGEMT, depending 3237 on the operating system version. Here we detect when a SIGILL or 3238 SIGEMT is really a breakpoint and change it to SIGTRAP. We do 3239 something similar for SIGSEGV, since a SIGSEGV will be generated 3240 when we're trying to execute a breakpoint instruction on a 3241 non-executable stack. This happens for call dummy breakpoints 3242 for architectures like SPARC that place call dummies on the 3243 stack. */ 3244 if (ecs->ws.kind == TARGET_WAITKIND_STOPPED 3245 && (ecs->ws.value.sig == TARGET_SIGNAL_ILL 3246 || ecs->ws.value.sig == TARGET_SIGNAL_SEGV 3247 || ecs->ws.value.sig == TARGET_SIGNAL_EMT)) 3248 { 3249 struct regcache *regcache = get_thread_regcache (ecs->ptid); 3250 3251 if (breakpoint_inserted_here_p (get_regcache_aspace (regcache), 3252 regcache_read_pc (regcache))) 3253 { 3254 if (debug_infrun) 3255 fprintf_unfiltered (gdb_stdlog, 3256 "infrun: Treating signal as SIGTRAP\n"); 3257 ecs->ws.value.sig = TARGET_SIGNAL_TRAP; 3258 } 3259 } 3260 3261 /* Mark the non-executing threads accordingly. In all-stop, all 3262 threads of all processes are stopped when we get any event 3263 reported. In non-stop mode, only the event thread stops. If 3264 we're handling a process exit in non-stop mode, there's nothing 3265 to do, as threads of the dead process are gone, and threads of 3266 any other process were left running. */ 3267 if (!non_stop) 3268 set_executing (minus_one_ptid, 0); 3269 else if (ecs->ws.kind != TARGET_WAITKIND_SIGNALLED 3270 && ecs->ws.kind != TARGET_WAITKIND_EXITED) 3271 set_executing (ecs->ptid, 0); 3272 3273 switch (infwait_state) 3274 { 3275 case infwait_thread_hop_state: 3276 if (debug_infrun) 3277 fprintf_unfiltered (gdb_stdlog, "infrun: infwait_thread_hop_state\n"); 3278 break; 3279 3280 case infwait_normal_state: 3281 if (debug_infrun) 3282 fprintf_unfiltered (gdb_stdlog, "infrun: infwait_normal_state\n"); 3283 break; 3284 3285 case infwait_step_watch_state: 3286 if (debug_infrun) 3287 fprintf_unfiltered (gdb_stdlog, 3288 "infrun: infwait_step_watch_state\n"); 3289 3290 stepped_after_stopped_by_watchpoint = 1; 3291 break; 3292 3293 case infwait_nonstep_watch_state: 3294 if (debug_infrun) 3295 fprintf_unfiltered (gdb_stdlog, 3296 "infrun: infwait_nonstep_watch_state\n"); 3297 insert_breakpoints (); 3298 3299 /* FIXME-maybe: is this cleaner than setting a flag? Does it 3300 handle things like signals arriving and other things happening 3301 in combination correctly? */ 3302 stepped_after_stopped_by_watchpoint = 1; 3303 break; 3304 3305 default: 3306 internal_error (__FILE__, __LINE__, _("bad switch")); 3307 } 3308 3309 infwait_state = infwait_normal_state; 3310 waiton_ptid = pid_to_ptid (-1); 3311 3312 switch (ecs->ws.kind) 3313 { 3314 case TARGET_WAITKIND_LOADED: 3315 if (debug_infrun) 3316 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_LOADED\n"); 3317 /* Ignore gracefully during startup of the inferior, as it might 3318 be the shell which has just loaded some objects, otherwise 3319 add the symbols for the newly loaded objects. Also ignore at 3320 the beginning of an attach or remote session; we will query 3321 the full list of libraries once the connection is 3322 established. */ 3323 if (stop_soon == NO_STOP_QUIETLY) 3324 { 3325 /* Check for any newly added shared libraries if we're 3326 supposed to be adding them automatically. Switch 3327 terminal for any messages produced by 3328 breakpoint_re_set. */ 3329 target_terminal_ours_for_output (); 3330 /* NOTE: cagney/2003-11-25: Make certain that the target 3331 stack's section table is kept up-to-date. Architectures, 3332 (e.g., PPC64), use the section table to perform 3333 operations such as address => section name and hence 3334 require the table to contain all sections (including 3335 those found in shared libraries). */ 3336 #ifdef SOLIB_ADD 3337 SOLIB_ADD (NULL, 0, ¤t_target, auto_solib_add); 3338 #else 3339 solib_add (NULL, 0, ¤t_target, auto_solib_add); 3340 #endif 3341 target_terminal_inferior (); 3342 3343 /* If requested, stop when the dynamic linker notifies 3344 gdb of events. This allows the user to get control 3345 and place breakpoints in initializer routines for 3346 dynamically loaded objects (among other things). */ 3347 if (stop_on_solib_events) 3348 { 3349 /* Make sure we print "Stopped due to solib-event" in 3350 normal_stop. */ 3351 stop_print_frame = 1; 3352 3353 stop_stepping (ecs); 3354 return; 3355 } 3356 3357 /* NOTE drow/2007-05-11: This might be a good place to check 3358 for "catch load". */ 3359 } 3360 3361 /* If we are skipping through a shell, or through shared library 3362 loading that we aren't interested in, resume the program. If 3363 we're running the program normally, also resume. But stop if 3364 we're attaching or setting up a remote connection. */ 3365 if (stop_soon == STOP_QUIETLY || stop_soon == NO_STOP_QUIETLY) 3366 { 3367 /* Loading of shared libraries might have changed breakpoint 3368 addresses. Make sure new breakpoints are inserted. */ 3369 if (stop_soon == NO_STOP_QUIETLY 3370 && !breakpoints_always_inserted_mode ()) 3371 insert_breakpoints (); 3372 resume (0, TARGET_SIGNAL_0); 3373 prepare_to_wait (ecs); 3374 return; 3375 } 3376 3377 break; 3378 3379 case TARGET_WAITKIND_SPURIOUS: 3380 if (debug_infrun) 3381 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_SPURIOUS\n"); 3382 resume (0, TARGET_SIGNAL_0); 3383 prepare_to_wait (ecs); 3384 return; 3385 3386 case TARGET_WAITKIND_EXITED: 3387 if (debug_infrun) 3388 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_EXITED\n"); 3389 inferior_ptid = ecs->ptid; 3390 set_current_inferior (find_inferior_pid (ptid_get_pid (ecs->ptid))); 3391 set_current_program_space (current_inferior ()->pspace); 3392 handle_vfork_child_exec_or_exit (0); 3393 target_terminal_ours (); /* Must do this before mourn anyway. */ 3394 print_exited_reason (ecs->ws.value.integer); 3395 3396 /* Record the exit code in the convenience variable $_exitcode, so 3397 that the user can inspect this again later. */ 3398 set_internalvar_integer (lookup_internalvar ("_exitcode"), 3399 (LONGEST) ecs->ws.value.integer); 3400 3401 /* Also record this in the inferior itself. */ 3402 current_inferior ()->has_exit_code = 1; 3403 current_inferior ()->exit_code = (LONGEST) ecs->ws.value.integer; 3404 3405 gdb_flush (gdb_stdout); 3406 target_mourn_inferior (); 3407 singlestep_breakpoints_inserted_p = 0; 3408 cancel_single_step_breakpoints (); 3409 stop_print_frame = 0; 3410 stop_stepping (ecs); 3411 return; 3412 3413 case TARGET_WAITKIND_SIGNALLED: 3414 if (debug_infrun) 3415 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_SIGNALLED\n"); 3416 inferior_ptid = ecs->ptid; 3417 set_current_inferior (find_inferior_pid (ptid_get_pid (ecs->ptid))); 3418 set_current_program_space (current_inferior ()->pspace); 3419 handle_vfork_child_exec_or_exit (0); 3420 stop_print_frame = 0; 3421 target_terminal_ours (); /* Must do this before mourn anyway. */ 3422 3423 /* Note: By definition of TARGET_WAITKIND_SIGNALLED, we shouldn't 3424 reach here unless the inferior is dead. However, for years 3425 target_kill() was called here, which hints that fatal signals aren't 3426 really fatal on some systems. If that's true, then some changes 3427 may be needed. */ 3428 target_mourn_inferior (); 3429 3430 print_signal_exited_reason (ecs->ws.value.sig); 3431 singlestep_breakpoints_inserted_p = 0; 3432 cancel_single_step_breakpoints (); 3433 stop_stepping (ecs); 3434 return; 3435 3436 /* The following are the only cases in which we keep going; 3437 the above cases end in a continue or goto. */ 3438 case TARGET_WAITKIND_FORKED: 3439 case TARGET_WAITKIND_VFORKED: 3440 if (debug_infrun) 3441 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_FORKED\n"); 3442 3443 /* Check whether the inferior is displaced stepping. */ 3444 { 3445 struct regcache *regcache = get_thread_regcache (ecs->ptid); 3446 struct gdbarch *gdbarch = get_regcache_arch (regcache); 3447 struct displaced_step_inferior_state *displaced 3448 = get_displaced_stepping_state (ptid_get_pid (ecs->ptid)); 3449 3450 /* If checking displaced stepping is supported, and thread 3451 ecs->ptid is displaced stepping. */ 3452 if (displaced && ptid_equal (displaced->step_ptid, ecs->ptid)) 3453 { 3454 struct inferior *parent_inf 3455 = find_inferior_pid (ptid_get_pid (ecs->ptid)); 3456 struct regcache *child_regcache; 3457 CORE_ADDR parent_pc; 3458 3459 /* GDB has got TARGET_WAITKIND_FORKED or TARGET_WAITKIND_VFORKED, 3460 indicating that the displaced stepping of syscall instruction 3461 has been done. Perform cleanup for parent process here. Note 3462 that this operation also cleans up the child process for vfork, 3463 because their pages are shared. */ 3464 displaced_step_fixup (ecs->ptid, TARGET_SIGNAL_TRAP); 3465 3466 if (ecs->ws.kind == TARGET_WAITKIND_FORKED) 3467 { 3468 /* Restore scratch pad for child process. */ 3469 displaced_step_restore (displaced, ecs->ws.value.related_pid); 3470 } 3471 3472 /* Since the vfork/fork syscall instruction was executed in the scratchpad, 3473 the child's PC is also within the scratchpad. Set the child's PC 3474 to the parent's PC value, which has already been fixed up. 3475 FIXME: we use the parent's aspace here, although we're touching 3476 the child, because the child hasn't been added to the inferior 3477 list yet at this point. */ 3478 3479 child_regcache 3480 = get_thread_arch_aspace_regcache (ecs->ws.value.related_pid, 3481 gdbarch, 3482 parent_inf->aspace); 3483 /* Read PC value of parent process. */ 3484 parent_pc = regcache_read_pc (regcache); 3485 3486 if (debug_displaced) 3487 fprintf_unfiltered (gdb_stdlog, 3488 "displaced: write child pc from %s to %s\n", 3489 paddress (gdbarch, 3490 regcache_read_pc (child_regcache)), 3491 paddress (gdbarch, parent_pc)); 3492 3493 regcache_write_pc (child_regcache, parent_pc); 3494 } 3495 } 3496 3497 if (!ptid_equal (ecs->ptid, inferior_ptid)) 3498 { 3499 context_switch (ecs->ptid); 3500 reinit_frame_cache (); 3501 } 3502 3503 /* Immediately detach breakpoints from the child before there's 3504 any chance of letting the user delete breakpoints from the 3505 breakpoint lists. If we don't do this early, it's easy to 3506 leave left over traps in the child, vis: "break foo; catch 3507 fork; c; <fork>; del; c; <child calls foo>". We only follow 3508 the fork on the last `continue', and by that time the 3509 breakpoint at "foo" is long gone from the breakpoint table. 3510 If we vforked, then we don't need to unpatch here, since both 3511 parent and child are sharing the same memory pages; we'll 3512 need to unpatch at follow/detach time instead to be certain 3513 that new breakpoints added between catchpoint hit time and 3514 vfork follow are detached. */ 3515 if (ecs->ws.kind != TARGET_WAITKIND_VFORKED) 3516 { 3517 int child_pid = ptid_get_pid (ecs->ws.value.related_pid); 3518 3519 /* This won't actually modify the breakpoint list, but will 3520 physically remove the breakpoints from the child. */ 3521 detach_breakpoints (child_pid); 3522 } 3523 3524 if (singlestep_breakpoints_inserted_p) 3525 { 3526 /* Pull the single step breakpoints out of the target. */ 3527 remove_single_step_breakpoints (); 3528 singlestep_breakpoints_inserted_p = 0; 3529 } 3530 3531 /* In case the event is caught by a catchpoint, remember that 3532 the event is to be followed at the next resume of the thread, 3533 and not immediately. */ 3534 ecs->event_thread->pending_follow = ecs->ws; 3535 3536 stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid)); 3537 3538 ecs->event_thread->control.stop_bpstat 3539 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()), 3540 stop_pc, ecs->ptid); 3541 3542 /* Note that we're interested in knowing the bpstat actually 3543 causes a stop, not just if it may explain the signal. 3544 Software watchpoints, for example, always appear in the 3545 bpstat. */ 3546 ecs->random_signal 3547 = !bpstat_causes_stop (ecs->event_thread->control.stop_bpstat); 3548 3549 /* If no catchpoint triggered for this, then keep going. */ 3550 if (ecs->random_signal) 3551 { 3552 ptid_t parent; 3553 ptid_t child; 3554 int should_resume; 3555 int follow_child 3556 = (follow_fork_mode_string == follow_fork_mode_child); 3557 3558 ecs->event_thread->suspend.stop_signal = TARGET_SIGNAL_0; 3559 3560 should_resume = follow_fork (); 3561 3562 parent = ecs->ptid; 3563 child = ecs->ws.value.related_pid; 3564 3565 /* In non-stop mode, also resume the other branch. */ 3566 if (non_stop && !detach_fork) 3567 { 3568 if (follow_child) 3569 switch_to_thread (parent); 3570 else 3571 switch_to_thread (child); 3572 3573 ecs->event_thread = inferior_thread (); 3574 ecs->ptid = inferior_ptid; 3575 keep_going (ecs); 3576 } 3577 3578 if (follow_child) 3579 switch_to_thread (child); 3580 else 3581 switch_to_thread (parent); 3582 3583 ecs->event_thread = inferior_thread (); 3584 ecs->ptid = inferior_ptid; 3585 3586 if (should_resume) 3587 keep_going (ecs); 3588 else 3589 stop_stepping (ecs); 3590 return; 3591 } 3592 ecs->event_thread->suspend.stop_signal = TARGET_SIGNAL_TRAP; 3593 goto process_event_stop_test; 3594 3595 case TARGET_WAITKIND_VFORK_DONE: 3596 /* Done with the shared memory region. Re-insert breakpoints in 3597 the parent, and keep going. */ 3598 3599 if (debug_infrun) 3600 fprintf_unfiltered (gdb_stdlog, 3601 "infrun: TARGET_WAITKIND_VFORK_DONE\n"); 3602 3603 if (!ptid_equal (ecs->ptid, inferior_ptid)) 3604 context_switch (ecs->ptid); 3605 3606 current_inferior ()->waiting_for_vfork_done = 0; 3607 current_inferior ()->pspace->breakpoints_not_allowed = 0; 3608 /* This also takes care of reinserting breakpoints in the 3609 previously locked inferior. */ 3610 keep_going (ecs); 3611 return; 3612 3613 case TARGET_WAITKIND_EXECD: 3614 if (debug_infrun) 3615 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_EXECD\n"); 3616 3617 if (!ptid_equal (ecs->ptid, inferior_ptid)) 3618 { 3619 context_switch (ecs->ptid); 3620 reinit_frame_cache (); 3621 } 3622 3623 singlestep_breakpoints_inserted_p = 0; 3624 cancel_single_step_breakpoints (); 3625 3626 stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid)); 3627 3628 /* Do whatever is necessary to the parent branch of the vfork. */ 3629 handle_vfork_child_exec_or_exit (1); 3630 3631 /* This causes the eventpoints and symbol table to be reset. 3632 Must do this now, before trying to determine whether to 3633 stop. */ 3634 follow_exec (inferior_ptid, ecs->ws.value.execd_pathname); 3635 3636 ecs->event_thread->control.stop_bpstat 3637 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()), 3638 stop_pc, ecs->ptid); 3639 ecs->random_signal 3640 = !bpstat_explains_signal (ecs->event_thread->control.stop_bpstat); 3641 3642 /* Note that this may be referenced from inside 3643 bpstat_stop_status above, through inferior_has_execd. */ 3644 xfree (ecs->ws.value.execd_pathname); 3645 ecs->ws.value.execd_pathname = NULL; 3646 3647 /* If no catchpoint triggered for this, then keep going. */ 3648 if (ecs->random_signal) 3649 { 3650 ecs->event_thread->suspend.stop_signal = TARGET_SIGNAL_0; 3651 keep_going (ecs); 3652 return; 3653 } 3654 ecs->event_thread->suspend.stop_signal = TARGET_SIGNAL_TRAP; 3655 goto process_event_stop_test; 3656 3657 /* Be careful not to try to gather much state about a thread 3658 that's in a syscall. It's frequently a losing proposition. */ 3659 case TARGET_WAITKIND_SYSCALL_ENTRY: 3660 if (debug_infrun) 3661 fprintf_unfiltered (gdb_stdlog, 3662 "infrun: TARGET_WAITKIND_SYSCALL_ENTRY\n"); 3663 /* Getting the current syscall number. */ 3664 if (handle_syscall_event (ecs) != 0) 3665 return; 3666 goto process_event_stop_test; 3667 3668 /* Before examining the threads further, step this thread to 3669 get it entirely out of the syscall. (We get notice of the 3670 event when the thread is just on the verge of exiting a 3671 syscall. Stepping one instruction seems to get it back 3672 into user code.) */ 3673 case TARGET_WAITKIND_SYSCALL_RETURN: 3674 if (debug_infrun) 3675 fprintf_unfiltered (gdb_stdlog, 3676 "infrun: TARGET_WAITKIND_SYSCALL_RETURN\n"); 3677 if (handle_syscall_event (ecs) != 0) 3678 return; 3679 goto process_event_stop_test; 3680 3681 case TARGET_WAITKIND_STOPPED: 3682 if (debug_infrun) 3683 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_STOPPED\n"); 3684 ecs->event_thread->suspend.stop_signal = ecs->ws.value.sig; 3685 break; 3686 3687 case TARGET_WAITKIND_NO_HISTORY: 3688 if (debug_infrun) 3689 fprintf_unfiltered (gdb_stdlog, "infrun: TARGET_WAITKIND_NO_HISTORY\n"); 3690 /* Reverse execution: target ran out of history info. */ 3691 stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid)); 3692 print_no_history_reason (); 3693 stop_stepping (ecs); 3694 return; 3695 } 3696 3697 if (ecs->new_thread_event) 3698 { 3699 if (non_stop) 3700 /* Non-stop assumes that the target handles adding new threads 3701 to the thread list. */ 3702 internal_error (__FILE__, __LINE__, 3703 "targets should add new threads to the thread " 3704 "list themselves in non-stop mode."); 3705 3706 /* We may want to consider not doing a resume here in order to 3707 give the user a chance to play with the new thread. It might 3708 be good to make that a user-settable option. */ 3709 3710 /* At this point, all threads are stopped (happens automatically 3711 in either the OS or the native code). Therefore we need to 3712 continue all threads in order to make progress. */ 3713 3714 if (!ptid_equal (ecs->ptid, inferior_ptid)) 3715 context_switch (ecs->ptid); 3716 target_resume (RESUME_ALL, 0, TARGET_SIGNAL_0); 3717 prepare_to_wait (ecs); 3718 return; 3719 } 3720 3721 if (ecs->ws.kind == TARGET_WAITKIND_STOPPED) 3722 { 3723 /* Do we need to clean up the state of a thread that has 3724 completed a displaced single-step? (Doing so usually affects 3725 the PC, so do it here, before we set stop_pc.) */ 3726 displaced_step_fixup (ecs->ptid, 3727 ecs->event_thread->suspend.stop_signal); 3728 3729 /* If we either finished a single-step or hit a breakpoint, but 3730 the user wanted this thread to be stopped, pretend we got a 3731 SIG0 (generic unsignaled stop). */ 3732 3733 if (ecs->event_thread->stop_requested 3734 && ecs->event_thread->suspend.stop_signal == TARGET_SIGNAL_TRAP) 3735 ecs->event_thread->suspend.stop_signal = TARGET_SIGNAL_0; 3736 } 3737 3738 stop_pc = regcache_read_pc (get_thread_regcache (ecs->ptid)); 3739 3740 if (debug_infrun) 3741 { 3742 struct regcache *regcache = get_thread_regcache (ecs->ptid); 3743 struct gdbarch *gdbarch = get_regcache_arch (regcache); 3744 struct cleanup *old_chain = save_inferior_ptid (); 3745 3746 inferior_ptid = ecs->ptid; 3747 3748 fprintf_unfiltered (gdb_stdlog, "infrun: stop_pc = %s\n", 3749 paddress (gdbarch, stop_pc)); 3750 if (target_stopped_by_watchpoint ()) 3751 { 3752 CORE_ADDR addr; 3753 3754 fprintf_unfiltered (gdb_stdlog, "infrun: stopped by watchpoint\n"); 3755 3756 if (target_stopped_data_address (¤t_target, &addr)) 3757 fprintf_unfiltered (gdb_stdlog, 3758 "infrun: stopped data address = %s\n", 3759 paddress (gdbarch, addr)); 3760 else 3761 fprintf_unfiltered (gdb_stdlog, 3762 "infrun: (no data address available)\n"); 3763 } 3764 3765 do_cleanups (old_chain); 3766 } 3767 3768 if (stepping_past_singlestep_breakpoint) 3769 { 3770 gdb_assert (singlestep_breakpoints_inserted_p); 3771 gdb_assert (ptid_equal (singlestep_ptid, ecs->ptid)); 3772 gdb_assert (!ptid_equal (singlestep_ptid, saved_singlestep_ptid)); 3773 3774 stepping_past_singlestep_breakpoint = 0; 3775 3776 /* We've either finished single-stepping past the single-step 3777 breakpoint, or stopped for some other reason. It would be nice if 3778 we could tell, but we can't reliably. */ 3779 if (ecs->event_thread->suspend.stop_signal == TARGET_SIGNAL_TRAP) 3780 { 3781 if (debug_infrun) 3782 fprintf_unfiltered (gdb_stdlog, 3783 "infrun: stepping_past_" 3784 "singlestep_breakpoint\n"); 3785 /* Pull the single step breakpoints out of the target. */ 3786 remove_single_step_breakpoints (); 3787 singlestep_breakpoints_inserted_p = 0; 3788 3789 ecs->random_signal = 0; 3790 ecs->event_thread->control.trap_expected = 0; 3791 3792 context_switch (saved_singlestep_ptid); 3793 if (deprecated_context_hook) 3794 deprecated_context_hook (pid_to_thread_id (ecs->ptid)); 3795 3796 resume (1, TARGET_SIGNAL_0); 3797 prepare_to_wait (ecs); 3798 return; 3799 } 3800 } 3801 3802 if (!ptid_equal (deferred_step_ptid, null_ptid)) 3803 { 3804 /* In non-stop mode, there's never a deferred_step_ptid set. */ 3805 gdb_assert (!non_stop); 3806 3807 /* If we stopped for some other reason than single-stepping, ignore 3808 the fact that we were supposed to switch back. */ 3809 if (ecs->event_thread->suspend.stop_signal == TARGET_SIGNAL_TRAP) 3810 { 3811 if (debug_infrun) 3812 fprintf_unfiltered (gdb_stdlog, 3813 "infrun: handling deferred step\n"); 3814 3815 /* Pull the single step breakpoints out of the target. */ 3816 if (singlestep_breakpoints_inserted_p) 3817 { 3818 remove_single_step_breakpoints (); 3819 singlestep_breakpoints_inserted_p = 0; 3820 } 3821 3822 ecs->event_thread->control.trap_expected = 0; 3823 3824 /* Note: We do not call context_switch at this point, as the 3825 context is already set up for stepping the original thread. */ 3826 switch_to_thread (deferred_step_ptid); 3827 deferred_step_ptid = null_ptid; 3828 /* Suppress spurious "Switching to ..." message. */ 3829 previous_inferior_ptid = inferior_ptid; 3830 3831 resume (1, TARGET_SIGNAL_0); 3832 prepare_to_wait (ecs); 3833 return; 3834 } 3835 3836 deferred_step_ptid = null_ptid; 3837 } 3838 3839 /* See if a thread hit a thread-specific breakpoint that was meant for 3840 another thread. If so, then step that thread past the breakpoint, 3841 and continue it. */ 3842 3843 if (ecs->event_thread->suspend.stop_signal == TARGET_SIGNAL_TRAP) 3844 { 3845 int thread_hop_needed = 0; 3846 struct address_space *aspace = 3847 get_regcache_aspace (get_thread_regcache (ecs->ptid)); 3848 3849 /* Check if a regular breakpoint has been hit before checking 3850 for a potential single step breakpoint. Otherwise, GDB will 3851 not see this breakpoint hit when stepping onto breakpoints. */ 3852 if (regular_breakpoint_inserted_here_p (aspace, stop_pc)) 3853 { 3854 ecs->random_signal = 0; 3855 if (!breakpoint_thread_match (aspace, stop_pc, ecs->ptid)) 3856 thread_hop_needed = 1; 3857 } 3858 else if (singlestep_breakpoints_inserted_p) 3859 { 3860 /* We have not context switched yet, so this should be true 3861 no matter which thread hit the singlestep breakpoint. */ 3862 gdb_assert (ptid_equal (inferior_ptid, singlestep_ptid)); 3863 if (debug_infrun) 3864 fprintf_unfiltered (gdb_stdlog, "infrun: software single step " 3865 "trap for %s\n", 3866 target_pid_to_str (ecs->ptid)); 3867 3868 ecs->random_signal = 0; 3869 /* The call to in_thread_list is necessary because PTIDs sometimes 3870 change when we go from single-threaded to multi-threaded. If 3871 the singlestep_ptid is still in the list, assume that it is 3872 really different from ecs->ptid. */ 3873 if (!ptid_equal (singlestep_ptid, ecs->ptid) 3874 && in_thread_list (singlestep_ptid)) 3875 { 3876 /* If the PC of the thread we were trying to single-step 3877 has changed, discard this event (which we were going 3878 to ignore anyway), and pretend we saw that thread 3879 trap. This prevents us continuously moving the 3880 single-step breakpoint forward, one instruction at a 3881 time. If the PC has changed, then the thread we were 3882 trying to single-step has trapped or been signalled, 3883 but the event has not been reported to GDB yet. 3884 3885 There might be some cases where this loses signal 3886 information, if a signal has arrived at exactly the 3887 same time that the PC changed, but this is the best 3888 we can do with the information available. Perhaps we 3889 should arrange to report all events for all threads 3890 when they stop, or to re-poll the remote looking for 3891 this particular thread (i.e. temporarily enable 3892 schedlock). */ 3893 3894 CORE_ADDR new_singlestep_pc 3895 = regcache_read_pc (get_thread_regcache (singlestep_ptid)); 3896 3897 if (new_singlestep_pc != singlestep_pc) 3898 { 3899 enum target_signal stop_signal; 3900 3901 if (debug_infrun) 3902 fprintf_unfiltered (gdb_stdlog, "infrun: unexpected thread," 3903 " but expected thread advanced also\n"); 3904 3905 /* The current context still belongs to 3906 singlestep_ptid. Don't swap here, since that's 3907 the context we want to use. Just fudge our 3908 state and continue. */ 3909 stop_signal = ecs->event_thread->suspend.stop_signal; 3910 ecs->event_thread->suspend.stop_signal = TARGET_SIGNAL_0; 3911 ecs->ptid = singlestep_ptid; 3912 ecs->event_thread = find_thread_ptid (ecs->ptid); 3913 ecs->event_thread->suspend.stop_signal = stop_signal; 3914 stop_pc = new_singlestep_pc; 3915 } 3916 else 3917 { 3918 if (debug_infrun) 3919 fprintf_unfiltered (gdb_stdlog, 3920 "infrun: unexpected thread\n"); 3921 3922 thread_hop_needed = 1; 3923 stepping_past_singlestep_breakpoint = 1; 3924 saved_singlestep_ptid = singlestep_ptid; 3925 } 3926 } 3927 } 3928 3929 if (thread_hop_needed) 3930 { 3931 struct regcache *thread_regcache; 3932 int remove_status = 0; 3933 3934 if (debug_infrun) 3935 fprintf_unfiltered (gdb_stdlog, "infrun: thread_hop_needed\n"); 3936 3937 /* Switch context before touching inferior memory, the 3938 previous thread may have exited. */ 3939 if (!ptid_equal (inferior_ptid, ecs->ptid)) 3940 context_switch (ecs->ptid); 3941 3942 /* Saw a breakpoint, but it was hit by the wrong thread. 3943 Just continue. */ 3944 3945 if (singlestep_breakpoints_inserted_p) 3946 { 3947 /* Pull the single step breakpoints out of the target. */ 3948 remove_single_step_breakpoints (); 3949 singlestep_breakpoints_inserted_p = 0; 3950 } 3951 3952 /* If the arch can displace step, don't remove the 3953 breakpoints. */ 3954 thread_regcache = get_thread_regcache (ecs->ptid); 3955 if (!use_displaced_stepping (get_regcache_arch (thread_regcache))) 3956 remove_status = remove_breakpoints (); 3957 3958 /* Did we fail to remove breakpoints? If so, try 3959 to set the PC past the bp. (There's at least 3960 one situation in which we can fail to remove 3961 the bp's: On HP-UX's that use ttrace, we can't 3962 change the address space of a vforking child 3963 process until the child exits (well, okay, not 3964 then either :-) or execs. */ 3965 if (remove_status != 0) 3966 error (_("Cannot step over breakpoint hit in wrong thread")); 3967 else 3968 { /* Single step */ 3969 if (!non_stop) 3970 { 3971 /* Only need to require the next event from this 3972 thread in all-stop mode. */ 3973 waiton_ptid = ecs->ptid; 3974 infwait_state = infwait_thread_hop_state; 3975 } 3976 3977 ecs->event_thread->stepping_over_breakpoint = 1; 3978 keep_going (ecs); 3979 return; 3980 } 3981 } 3982 else if (singlestep_breakpoints_inserted_p) 3983 { 3984 ecs->random_signal = 0; 3985 } 3986 } 3987 else 3988 ecs->random_signal = 1; 3989 3990 /* See if something interesting happened to the non-current thread. If 3991 so, then switch to that thread. */ 3992 if (!ptid_equal (ecs->ptid, inferior_ptid)) 3993 { 3994 if (debug_infrun) 3995 fprintf_unfiltered (gdb_stdlog, "infrun: context switch\n"); 3996 3997 context_switch (ecs->ptid); 3998 3999 if (deprecated_context_hook) 4000 deprecated_context_hook (pid_to_thread_id (ecs->ptid)); 4001 } 4002 4003 /* At this point, get hold of the now-current thread's frame. */ 4004 frame = get_current_frame (); 4005 gdbarch = get_frame_arch (frame); 4006 4007 if (singlestep_breakpoints_inserted_p) 4008 { 4009 /* Pull the single step breakpoints out of the target. */ 4010 remove_single_step_breakpoints (); 4011 singlestep_breakpoints_inserted_p = 0; 4012 } 4013 4014 if (stepped_after_stopped_by_watchpoint) 4015 stopped_by_watchpoint = 0; 4016 else 4017 stopped_by_watchpoint = watchpoints_triggered (&ecs->ws); 4018 4019 /* If necessary, step over this watchpoint. We'll be back to display 4020 it in a moment. */ 4021 if (stopped_by_watchpoint 4022 && (target_have_steppable_watchpoint 4023 || gdbarch_have_nonsteppable_watchpoint (gdbarch))) 4024 { 4025 /* At this point, we are stopped at an instruction which has 4026 attempted to write to a piece of memory under control of 4027 a watchpoint. The instruction hasn't actually executed 4028 yet. If we were to evaluate the watchpoint expression 4029 now, we would get the old value, and therefore no change 4030 would seem to have occurred. 4031 4032 In order to make watchpoints work `right', we really need 4033 to complete the memory write, and then evaluate the 4034 watchpoint expression. We do this by single-stepping the 4035 target. 4036 4037 It may not be necessary to disable the watchpoint to stop over 4038 it. For example, the PA can (with some kernel cooperation) 4039 single step over a watchpoint without disabling the watchpoint. 4040 4041 It is far more common to need to disable a watchpoint to step 4042 the inferior over it. If we have non-steppable watchpoints, 4043 we must disable the current watchpoint; it's simplest to 4044 disable all watchpoints and breakpoints. */ 4045 int hw_step = 1; 4046 4047 if (!target_have_steppable_watchpoint) 4048 { 4049 remove_breakpoints (); 4050 /* See comment in resume why we need to stop bypassing signals 4051 while breakpoints have been removed. */ 4052 target_pass_signals (0, NULL); 4053 } 4054 /* Single step */ 4055 hw_step = maybe_software_singlestep (gdbarch, stop_pc); 4056 target_resume (ecs->ptid, hw_step, TARGET_SIGNAL_0); 4057 waiton_ptid = ecs->ptid; 4058 if (target_have_steppable_watchpoint) 4059 infwait_state = infwait_step_watch_state; 4060 else 4061 infwait_state = infwait_nonstep_watch_state; 4062 prepare_to_wait (ecs); 4063 return; 4064 } 4065 4066 clear_stop_func (ecs); 4067 ecs->event_thread->stepping_over_breakpoint = 0; 4068 bpstat_clear (&ecs->event_thread->control.stop_bpstat); 4069 ecs->event_thread->control.stop_step = 0; 4070 stop_print_frame = 1; 4071 ecs->random_signal = 0; 4072 stopped_by_random_signal = 0; 4073 4074 /* Hide inlined functions starting here, unless we just performed stepi or 4075 nexti. After stepi and nexti, always show the innermost frame (not any 4076 inline function call sites). */ 4077 if (ecs->event_thread->control.step_range_end != 1) 4078 { 4079 struct address_space *aspace = 4080 get_regcache_aspace (get_thread_regcache (ecs->ptid)); 4081 4082 /* skip_inline_frames is expensive, so we avoid it if we can 4083 determine that the address is one where functions cannot have 4084 been inlined. This improves performance with inferiors that 4085 load a lot of shared libraries, because the solib event 4086 breakpoint is defined as the address of a function (i.e. not 4087 inline). Note that we have to check the previous PC as well 4088 as the current one to catch cases when we have just 4089 single-stepped off a breakpoint prior to reinstating it. 4090 Note that we're assuming that the code we single-step to is 4091 not inline, but that's not definitive: there's nothing 4092 preventing the event breakpoint function from containing 4093 inlined code, and the single-step ending up there. If the 4094 user had set a breakpoint on that inlined code, the missing 4095 skip_inline_frames call would break things. Fortunately 4096 that's an extremely unlikely scenario. */ 4097 if (!pc_at_non_inline_function (aspace, stop_pc) 4098 && !(ecs->event_thread->suspend.stop_signal == TARGET_SIGNAL_TRAP 4099 && ecs->event_thread->control.trap_expected 4100 && pc_at_non_inline_function (aspace, 4101 ecs->event_thread->prev_pc))) 4102 skip_inline_frames (ecs->ptid); 4103 } 4104 4105 if (ecs->event_thread->suspend.stop_signal == TARGET_SIGNAL_TRAP 4106 && ecs->event_thread->control.trap_expected 4107 && gdbarch_single_step_through_delay_p (gdbarch) 4108 && currently_stepping (ecs->event_thread)) 4109 { 4110 /* We're trying to step off a breakpoint. Turns out that we're 4111 also on an instruction that needs to be stepped multiple 4112 times before it's been fully executing. E.g., architectures 4113 with a delay slot. It needs to be stepped twice, once for 4114 the instruction and once for the delay slot. */ 4115 int step_through_delay 4116 = gdbarch_single_step_through_delay (gdbarch, frame); 4117 4118 if (debug_infrun && step_through_delay) 4119 fprintf_unfiltered (gdb_stdlog, "infrun: step through delay\n"); 4120 if (ecs->event_thread->control.step_range_end == 0 4121 && step_through_delay) 4122 { 4123 /* The user issued a continue when stopped at a breakpoint. 4124 Set up for another trap and get out of here. */ 4125 ecs->event_thread->stepping_over_breakpoint = 1; 4126 keep_going (ecs); 4127 return; 4128 } 4129 else if (step_through_delay) 4130 { 4131 /* The user issued a step when stopped at a breakpoint. 4132 Maybe we should stop, maybe we should not - the delay 4133 slot *might* correspond to a line of source. In any 4134 case, don't decide that here, just set 4135 ecs->stepping_over_breakpoint, making sure we 4136 single-step again before breakpoints are re-inserted. */ 4137 ecs->event_thread->stepping_over_breakpoint = 1; 4138 } 4139 } 4140 4141 /* Look at the cause of the stop, and decide what to do. 4142 The alternatives are: 4143 1) stop_stepping and return; to really stop and return to the debugger, 4144 2) keep_going and return to start up again 4145 (set ecs->event_thread->stepping_over_breakpoint to 1 to single step once) 4146 3) set ecs->random_signal to 1, and the decision between 1 and 2 4147 will be made according to the signal handling tables. */ 4148 4149 if (ecs->event_thread->suspend.stop_signal == TARGET_SIGNAL_TRAP 4150 || stop_soon == STOP_QUIETLY || stop_soon == STOP_QUIETLY_NO_SIGSTOP 4151 || stop_soon == STOP_QUIETLY_REMOTE) 4152 { 4153 if (ecs->event_thread->suspend.stop_signal == TARGET_SIGNAL_TRAP 4154 && stop_after_trap) 4155 { 4156 if (debug_infrun) 4157 fprintf_unfiltered (gdb_stdlog, "infrun: stopped\n"); 4158 stop_print_frame = 0; 4159 stop_stepping (ecs); 4160 return; 4161 } 4162 4163 /* This is originated from start_remote(), start_inferior() and 4164 shared libraries hook functions. */ 4165 if (stop_soon == STOP_QUIETLY || stop_soon == STOP_QUIETLY_REMOTE) 4166 { 4167 if (debug_infrun) 4168 fprintf_unfiltered (gdb_stdlog, "infrun: quietly stopped\n"); 4169 stop_stepping (ecs); 4170 return; 4171 } 4172 4173 /* This originates from attach_command(). We need to overwrite 4174 the stop_signal here, because some kernels don't ignore a 4175 SIGSTOP in a subsequent ptrace(PTRACE_CONT,SIGSTOP) call. 4176 See more comments in inferior.h. On the other hand, if we 4177 get a non-SIGSTOP, report it to the user - assume the backend 4178 will handle the SIGSTOP if it should show up later. 4179 4180 Also consider that the attach is complete when we see a 4181 SIGTRAP. Some systems (e.g. Windows), and stubs supporting 4182 target extended-remote report it instead of a SIGSTOP 4183 (e.g. gdbserver). We already rely on SIGTRAP being our 4184 signal, so this is no exception. 4185 4186 Also consider that the attach is complete when we see a 4187 TARGET_SIGNAL_0. In non-stop mode, GDB will explicitly tell 4188 the target to stop all threads of the inferior, in case the 4189 low level attach operation doesn't stop them implicitly. If 4190 they weren't stopped implicitly, then the stub will report a 4191 TARGET_SIGNAL_0, meaning: stopped for no particular reason 4192 other than GDB's request. */ 4193 if (stop_soon == STOP_QUIETLY_NO_SIGSTOP 4194 && (ecs->event_thread->suspend.stop_signal == TARGET_SIGNAL_STOP 4195 || ecs->event_thread->suspend.stop_signal == TARGET_SIGNAL_TRAP 4196 || ecs->event_thread->suspend.stop_signal == TARGET_SIGNAL_0)) 4197 { 4198 stop_stepping (ecs); 4199 ecs->event_thread->suspend.stop_signal = TARGET_SIGNAL_0; 4200 return; 4201 } 4202 4203 /* See if there is a breakpoint at the current PC. */ 4204 ecs->event_thread->control.stop_bpstat 4205 = bpstat_stop_status (get_regcache_aspace (get_current_regcache ()), 4206 stop_pc, ecs->ptid); 4207 4208 /* Following in case break condition called a 4209 function. */ 4210 stop_print_frame = 1; 4211 4212 /* This is where we handle "moribund" watchpoints. Unlike 4213 software breakpoints traps, hardware watchpoint traps are 4214 always distinguishable from random traps. If no high-level 4215 watchpoint is associated with the reported stop data address 4216 anymore, then the bpstat does not explain the signal --- 4217 simply make sure to ignore it if `stopped_by_watchpoint' is 4218 set. */ 4219 4220 if (debug_infrun 4221 && ecs->event_thread->suspend.stop_signal == TARGET_SIGNAL_TRAP 4222 && !bpstat_explains_signal (ecs->event_thread->control.stop_bpstat) 4223 && stopped_by_watchpoint) 4224 fprintf_unfiltered (gdb_stdlog, 4225 "infrun: no user watchpoint explains " 4226 "watchpoint SIGTRAP, ignoring\n"); 4227 4228 /* NOTE: cagney/2003-03-29: These two checks for a random signal 4229 at one stage in the past included checks for an inferior 4230 function call's call dummy's return breakpoint. The original 4231 comment, that went with the test, read: 4232 4233 ``End of a stack dummy. Some systems (e.g. Sony news) give 4234 another signal besides SIGTRAP, so check here as well as 4235 above.'' 4236 4237 If someone ever tries to get call dummys on a 4238 non-executable stack to work (where the target would stop 4239 with something like a SIGSEGV), then those tests might need 4240 to be re-instated. Given, however, that the tests were only 4241 enabled when momentary breakpoints were not being used, I 4242 suspect that it won't be the case. 4243 4244 NOTE: kettenis/2004-02-05: Indeed such checks don't seem to 4245 be necessary for call dummies on a non-executable stack on 4246 SPARC. */ 4247 4248 if (ecs->event_thread->suspend.stop_signal == TARGET_SIGNAL_TRAP) 4249 ecs->random_signal 4250 = !(bpstat_explains_signal (ecs->event_thread->control.stop_bpstat) 4251 || stopped_by_watchpoint 4252 || ecs->event_thread->control.trap_expected 4253 || (ecs->event_thread->control.step_range_end 4254 && (ecs->event_thread->control.step_resume_breakpoint 4255 == NULL))); 4256 else 4257 { 4258 ecs->random_signal = !bpstat_explains_signal 4259 (ecs->event_thread->control.stop_bpstat); 4260 if (!ecs->random_signal) 4261 ecs->event_thread->suspend.stop_signal = TARGET_SIGNAL_TRAP; 4262 } 4263 } 4264 4265 /* When we reach this point, we've pretty much decided 4266 that the reason for stopping must've been a random 4267 (unexpected) signal. */ 4268 4269 else 4270 ecs->random_signal = 1; 4271 4272 process_event_stop_test: 4273 4274 /* Re-fetch current thread's frame in case we did a 4275 "goto process_event_stop_test" above. */ 4276 frame = get_current_frame (); 4277 gdbarch = get_frame_arch (frame); 4278 4279 /* For the program's own signals, act according to 4280 the signal handling tables. */ 4281 4282 if (ecs->random_signal) 4283 { 4284 /* Signal not for debugging purposes. */ 4285 int printed = 0; 4286 struct inferior *inf = find_inferior_pid (ptid_get_pid (ecs->ptid)); 4287 4288 if (debug_infrun) 4289 fprintf_unfiltered (gdb_stdlog, "infrun: random signal %d\n", 4290 ecs->event_thread->suspend.stop_signal); 4291 4292 stopped_by_random_signal = 1; 4293 4294 if (signal_print[ecs->event_thread->suspend.stop_signal]) 4295 { 4296 printed = 1; 4297 target_terminal_ours_for_output (); 4298 print_signal_received_reason 4299 (ecs->event_thread->suspend.stop_signal); 4300 } 4301 /* Always stop on signals if we're either just gaining control 4302 of the program, or the user explicitly requested this thread 4303 to remain stopped. */ 4304 if (stop_soon != NO_STOP_QUIETLY 4305 || ecs->event_thread->stop_requested 4306 || (!inf->detaching 4307 && signal_stop_state (ecs->event_thread->suspend.stop_signal))) 4308 { 4309 stop_stepping (ecs); 4310 return; 4311 } 4312 /* If not going to stop, give terminal back 4313 if we took it away. */ 4314 else if (printed) 4315 target_terminal_inferior (); 4316 4317 /* Clear the signal if it should not be passed. */ 4318 if (signal_program[ecs->event_thread->suspend.stop_signal] == 0) 4319 ecs->event_thread->suspend.stop_signal = TARGET_SIGNAL_0; 4320 4321 if (ecs->event_thread->prev_pc == stop_pc 4322 && ecs->event_thread->control.trap_expected 4323 && ecs->event_thread->control.step_resume_breakpoint == NULL) 4324 { 4325 /* We were just starting a new sequence, attempting to 4326 single-step off of a breakpoint and expecting a SIGTRAP. 4327 Instead this signal arrives. This signal will take us out 4328 of the stepping range so GDB needs to remember to, when 4329 the signal handler returns, resume stepping off that 4330 breakpoint. */ 4331 /* To simplify things, "continue" is forced to use the same 4332 code paths as single-step - set a breakpoint at the 4333 signal return address and then, once hit, step off that 4334 breakpoint. */ 4335 if (debug_infrun) 4336 fprintf_unfiltered (gdb_stdlog, 4337 "infrun: signal arrived while stepping over " 4338 "breakpoint\n"); 4339 4340 insert_hp_step_resume_breakpoint_at_frame (frame); 4341 ecs->event_thread->step_after_step_resume_breakpoint = 1; 4342 /* Reset trap_expected to ensure breakpoints are re-inserted. */ 4343 ecs->event_thread->control.trap_expected = 0; 4344 keep_going (ecs); 4345 return; 4346 } 4347 4348 if (ecs->event_thread->control.step_range_end != 0 4349 && ecs->event_thread->suspend.stop_signal != TARGET_SIGNAL_0 4350 && (ecs->event_thread->control.step_range_start <= stop_pc 4351 && stop_pc < ecs->event_thread->control.step_range_end) 4352 && frame_id_eq (get_stack_frame_id (frame), 4353 ecs->event_thread->control.step_stack_frame_id) 4354 && ecs->event_thread->control.step_resume_breakpoint == NULL) 4355 { 4356 /* The inferior is about to take a signal that will take it 4357 out of the single step range. Set a breakpoint at the 4358 current PC (which is presumably where the signal handler 4359 will eventually return) and then allow the inferior to 4360 run free. 4361 4362 Note that this is only needed for a signal delivered 4363 while in the single-step range. Nested signals aren't a 4364 problem as they eventually all return. */ 4365 if (debug_infrun) 4366 fprintf_unfiltered (gdb_stdlog, 4367 "infrun: signal may take us out of " 4368 "single-step range\n"); 4369 4370 insert_hp_step_resume_breakpoint_at_frame (frame); 4371 /* Reset trap_expected to ensure breakpoints are re-inserted. */ 4372 ecs->event_thread->control.trap_expected = 0; 4373 keep_going (ecs); 4374 return; 4375 } 4376 4377 /* Note: step_resume_breakpoint may be non-NULL. This occures 4378 when either there's a nested signal, or when there's a 4379 pending signal enabled just as the signal handler returns 4380 (leaving the inferior at the step-resume-breakpoint without 4381 actually executing it). Either way continue until the 4382 breakpoint is really hit. */ 4383 keep_going (ecs); 4384 return; 4385 } 4386 4387 /* Handle cases caused by hitting a breakpoint. */ 4388 { 4389 CORE_ADDR jmp_buf_pc; 4390 struct bpstat_what what; 4391 4392 what = bpstat_what (ecs->event_thread->control.stop_bpstat); 4393 4394 if (what.call_dummy) 4395 { 4396 stop_stack_dummy = what.call_dummy; 4397 } 4398 4399 /* If we hit an internal event that triggers symbol changes, the 4400 current frame will be invalidated within bpstat_what (e.g., if 4401 we hit an internal solib event). Re-fetch it. */ 4402 frame = get_current_frame (); 4403 gdbarch = get_frame_arch (frame); 4404 4405 switch (what.main_action) 4406 { 4407 case BPSTAT_WHAT_SET_LONGJMP_RESUME: 4408 /* If we hit the breakpoint at longjmp while stepping, we 4409 install a momentary breakpoint at the target of the 4410 jmp_buf. */ 4411 4412 if (debug_infrun) 4413 fprintf_unfiltered (gdb_stdlog, 4414 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME\n"); 4415 4416 ecs->event_thread->stepping_over_breakpoint = 1; 4417 4418 if (what.is_longjmp) 4419 { 4420 if (!gdbarch_get_longjmp_target_p (gdbarch) 4421 || !gdbarch_get_longjmp_target (gdbarch, 4422 frame, &jmp_buf_pc)) 4423 { 4424 if (debug_infrun) 4425 fprintf_unfiltered (gdb_stdlog, 4426 "infrun: BPSTAT_WHAT_SET_LONGJMP_RESUME " 4427 "(!gdbarch_get_longjmp_target)\n"); 4428 keep_going (ecs); 4429 return; 4430 } 4431 4432 /* We're going to replace the current step-resume breakpoint 4433 with a longjmp-resume breakpoint. */ 4434 delete_step_resume_breakpoint (ecs->event_thread); 4435 4436 /* Insert a breakpoint at resume address. */ 4437 insert_longjmp_resume_breakpoint (gdbarch, jmp_buf_pc); 4438 } 4439 else 4440 { 4441 struct symbol *func = get_frame_function (frame); 4442 4443 if (func) 4444 check_exception_resume (ecs, frame, func); 4445 } 4446 keep_going (ecs); 4447 return; 4448 4449 case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME: 4450 if (debug_infrun) 4451 fprintf_unfiltered (gdb_stdlog, 4452 "infrun: BPSTAT_WHAT_CLEAR_LONGJMP_RESUME\n"); 4453 4454 if (what.is_longjmp) 4455 { 4456 gdb_assert (ecs->event_thread->control.step_resume_breakpoint 4457 != NULL); 4458 delete_step_resume_breakpoint (ecs->event_thread); 4459 } 4460 else 4461 { 4462 /* There are several cases to consider. 4463 4464 1. The initiating frame no longer exists. In this case 4465 we must stop, because the exception has gone too far. 4466 4467 2. The initiating frame exists, and is the same as the 4468 current frame. We stop, because the exception has been 4469 caught. 4470 4471 3. The initiating frame exists and is different from 4472 the current frame. This means the exception has been 4473 caught beneath the initiating frame, so keep going. */ 4474 struct frame_info *init_frame 4475 = frame_find_by_id (ecs->event_thread->initiating_frame); 4476 4477 gdb_assert (ecs->event_thread->control.exception_resume_breakpoint 4478 != NULL); 4479 delete_exception_resume_breakpoint (ecs->event_thread); 4480 4481 if (init_frame) 4482 { 4483 struct frame_id current_id 4484 = get_frame_id (get_current_frame ()); 4485 if (frame_id_eq (current_id, 4486 ecs->event_thread->initiating_frame)) 4487 { 4488 /* Case 2. Fall through. */ 4489 } 4490 else 4491 { 4492 /* Case 3. */ 4493 keep_going (ecs); 4494 return; 4495 } 4496 } 4497 4498 /* For Cases 1 and 2, remove the step-resume breakpoint, 4499 if it exists. */ 4500 delete_step_resume_breakpoint (ecs->event_thread); 4501 } 4502 4503 ecs->event_thread->control.stop_step = 1; 4504 print_end_stepping_range_reason (); 4505 stop_stepping (ecs); 4506 return; 4507 4508 case BPSTAT_WHAT_SINGLE: 4509 if (debug_infrun) 4510 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_SINGLE\n"); 4511 ecs->event_thread->stepping_over_breakpoint = 1; 4512 /* Still need to check other stuff, at least the case 4513 where we are stepping and step out of the right range. */ 4514 break; 4515 4516 case BPSTAT_WHAT_STEP_RESUME: 4517 if (debug_infrun) 4518 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STEP_RESUME\n"); 4519 4520 delete_step_resume_breakpoint (ecs->event_thread); 4521 if (ecs->event_thread->control.proceed_to_finish 4522 && execution_direction == EXEC_REVERSE) 4523 { 4524 struct thread_info *tp = ecs->event_thread; 4525 4526 /* We are finishing a function in reverse, and just hit 4527 the step-resume breakpoint at the start address of the 4528 function, and we're almost there -- just need to back 4529 up by one more single-step, which should take us back 4530 to the function call. */ 4531 tp->control.step_range_start = tp->control.step_range_end = 1; 4532 keep_going (ecs); 4533 return; 4534 } 4535 fill_in_stop_func (gdbarch, ecs); 4536 if (stop_pc == ecs->stop_func_start 4537 && execution_direction == EXEC_REVERSE) 4538 { 4539 /* We are stepping over a function call in reverse, and 4540 just hit the step-resume breakpoint at the start 4541 address of the function. Go back to single-stepping, 4542 which should take us back to the function call. */ 4543 ecs->event_thread->stepping_over_breakpoint = 1; 4544 keep_going (ecs); 4545 return; 4546 } 4547 break; 4548 4549 case BPSTAT_WHAT_STOP_NOISY: 4550 if (debug_infrun) 4551 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_NOISY\n"); 4552 stop_print_frame = 1; 4553 4554 /* We are about to nuke the step_resume_breakpointt via the 4555 cleanup chain, so no need to worry about it here. */ 4556 4557 stop_stepping (ecs); 4558 return; 4559 4560 case BPSTAT_WHAT_STOP_SILENT: 4561 if (debug_infrun) 4562 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_STOP_SILENT\n"); 4563 stop_print_frame = 0; 4564 4565 /* We are about to nuke the step_resume_breakpoin via the 4566 cleanup chain, so no need to worry about it here. */ 4567 4568 stop_stepping (ecs); 4569 return; 4570 4571 case BPSTAT_WHAT_HP_STEP_RESUME: 4572 if (debug_infrun) 4573 fprintf_unfiltered (gdb_stdlog, "infrun: BPSTAT_WHAT_HP_STEP_RESUME\n"); 4574 4575 delete_step_resume_breakpoint (ecs->event_thread); 4576 if (ecs->event_thread->step_after_step_resume_breakpoint) 4577 { 4578 /* Back when the step-resume breakpoint was inserted, we 4579 were trying to single-step off a breakpoint. Go back 4580 to doing that. */ 4581 ecs->event_thread->step_after_step_resume_breakpoint = 0; 4582 ecs->event_thread->stepping_over_breakpoint = 1; 4583 keep_going (ecs); 4584 return; 4585 } 4586 break; 4587 4588 case BPSTAT_WHAT_KEEP_CHECKING: 4589 break; 4590 } 4591 } 4592 4593 /* We come here if we hit a breakpoint but should not 4594 stop for it. Possibly we also were stepping 4595 and should stop for that. So fall through and 4596 test for stepping. But, if not stepping, 4597 do not stop. */ 4598 4599 /* In all-stop mode, if we're currently stepping but have stopped in 4600 some other thread, we need to switch back to the stepped thread. */ 4601 if (!non_stop) 4602 { 4603 struct thread_info *tp; 4604 4605 tp = iterate_over_threads (currently_stepping_or_nexting_callback, 4606 ecs->event_thread); 4607 if (tp) 4608 { 4609 /* However, if the current thread is blocked on some internal 4610 breakpoint, and we simply need to step over that breakpoint 4611 to get it going again, do that first. */ 4612 if ((ecs->event_thread->control.trap_expected 4613 && ecs->event_thread->suspend.stop_signal != TARGET_SIGNAL_TRAP) 4614 || ecs->event_thread->stepping_over_breakpoint) 4615 { 4616 keep_going (ecs); 4617 return; 4618 } 4619 4620 /* If the stepping thread exited, then don't try to switch 4621 back and resume it, which could fail in several different 4622 ways depending on the target. Instead, just keep going. 4623 4624 We can find a stepping dead thread in the thread list in 4625 two cases: 4626 4627 - The target supports thread exit events, and when the 4628 target tries to delete the thread from the thread list, 4629 inferior_ptid pointed at the exiting thread. In such 4630 case, calling delete_thread does not really remove the 4631 thread from the list; instead, the thread is left listed, 4632 with 'exited' state. 4633 4634 - The target's debug interface does not support thread 4635 exit events, and so we have no idea whatsoever if the 4636 previously stepping thread is still alive. For that 4637 reason, we need to synchronously query the target 4638 now. */ 4639 if (is_exited (tp->ptid) 4640 || !target_thread_alive (tp->ptid)) 4641 { 4642 if (debug_infrun) 4643 fprintf_unfiltered (gdb_stdlog, 4644 "infrun: not switching back to " 4645 "stepped thread, it has vanished\n"); 4646 4647 delete_thread (tp->ptid); 4648 keep_going (ecs); 4649 return; 4650 } 4651 4652 /* Otherwise, we no longer expect a trap in the current thread. 4653 Clear the trap_expected flag before switching back -- this is 4654 what keep_going would do as well, if we called it. */ 4655 ecs->event_thread->control.trap_expected = 0; 4656 4657 if (debug_infrun) 4658 fprintf_unfiltered (gdb_stdlog, 4659 "infrun: switching back to stepped thread\n"); 4660 4661 ecs->event_thread = tp; 4662 ecs->ptid = tp->ptid; 4663 context_switch (ecs->ptid); 4664 keep_going (ecs); 4665 return; 4666 } 4667 } 4668 4669 if (ecs->event_thread->control.step_resume_breakpoint) 4670 { 4671 if (debug_infrun) 4672 fprintf_unfiltered (gdb_stdlog, 4673 "infrun: step-resume breakpoint is inserted\n"); 4674 4675 /* Having a step-resume breakpoint overrides anything 4676 else having to do with stepping commands until 4677 that breakpoint is reached. */ 4678 keep_going (ecs); 4679 return; 4680 } 4681 4682 if (ecs->event_thread->control.step_range_end == 0) 4683 { 4684 if (debug_infrun) 4685 fprintf_unfiltered (gdb_stdlog, "infrun: no stepping, continue\n"); 4686 /* Likewise if we aren't even stepping. */ 4687 keep_going (ecs); 4688 return; 4689 } 4690 4691 /* Re-fetch current thread's frame in case the code above caused 4692 the frame cache to be re-initialized, making our FRAME variable 4693 a dangling pointer. */ 4694 frame = get_current_frame (); 4695 gdbarch = get_frame_arch (frame); 4696 fill_in_stop_func (gdbarch, ecs); 4697 4698 /* If stepping through a line, keep going if still within it. 4699 4700 Note that step_range_end is the address of the first instruction 4701 beyond the step range, and NOT the address of the last instruction 4702 within it! 4703 4704 Note also that during reverse execution, we may be stepping 4705 through a function epilogue and therefore must detect when 4706 the current-frame changes in the middle of a line. */ 4707 4708 if (stop_pc >= ecs->event_thread->control.step_range_start 4709 && stop_pc < ecs->event_thread->control.step_range_end 4710 && (execution_direction != EXEC_REVERSE 4711 || frame_id_eq (get_frame_id (frame), 4712 ecs->event_thread->control.step_frame_id))) 4713 { 4714 if (debug_infrun) 4715 fprintf_unfiltered 4716 (gdb_stdlog, "infrun: stepping inside range [%s-%s]\n", 4717 paddress (gdbarch, ecs->event_thread->control.step_range_start), 4718 paddress (gdbarch, ecs->event_thread->control.step_range_end)); 4719 4720 /* When stepping backward, stop at beginning of line range 4721 (unless it's the function entry point, in which case 4722 keep going back to the call point). */ 4723 if (stop_pc == ecs->event_thread->control.step_range_start 4724 && stop_pc != ecs->stop_func_start 4725 && execution_direction == EXEC_REVERSE) 4726 { 4727 ecs->event_thread->control.stop_step = 1; 4728 print_end_stepping_range_reason (); 4729 stop_stepping (ecs); 4730 } 4731 else 4732 keep_going (ecs); 4733 4734 return; 4735 } 4736 4737 /* We stepped out of the stepping range. */ 4738 4739 /* If we are stepping at the source level and entered the runtime 4740 loader dynamic symbol resolution code... 4741 4742 EXEC_FORWARD: we keep on single stepping until we exit the run 4743 time loader code and reach the callee's address. 4744 4745 EXEC_REVERSE: we've already executed the callee (backward), and 4746 the runtime loader code is handled just like any other 4747 undebuggable function call. Now we need only keep stepping 4748 backward through the trampoline code, and that's handled further 4749 down, so there is nothing for us to do here. */ 4750 4751 if (execution_direction != EXEC_REVERSE 4752 && ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE 4753 && in_solib_dynsym_resolve_code (stop_pc)) 4754 { 4755 CORE_ADDR pc_after_resolver = 4756 gdbarch_skip_solib_resolver (gdbarch, stop_pc); 4757 4758 if (debug_infrun) 4759 fprintf_unfiltered (gdb_stdlog, 4760 "infrun: stepped into dynsym resolve code\n"); 4761 4762 if (pc_after_resolver) 4763 { 4764 /* Set up a step-resume breakpoint at the address 4765 indicated by SKIP_SOLIB_RESOLVER. */ 4766 struct symtab_and_line sr_sal; 4767 4768 init_sal (&sr_sal); 4769 sr_sal.pc = pc_after_resolver; 4770 sr_sal.pspace = get_frame_program_space (frame); 4771 4772 insert_step_resume_breakpoint_at_sal (gdbarch, 4773 sr_sal, null_frame_id); 4774 } 4775 4776 keep_going (ecs); 4777 return; 4778 } 4779 4780 if (ecs->event_thread->control.step_range_end != 1 4781 && (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE 4782 || ecs->event_thread->control.step_over_calls == STEP_OVER_ALL) 4783 && get_frame_type (frame) == SIGTRAMP_FRAME) 4784 { 4785 if (debug_infrun) 4786 fprintf_unfiltered (gdb_stdlog, 4787 "infrun: stepped into signal trampoline\n"); 4788 /* The inferior, while doing a "step" or "next", has ended up in 4789 a signal trampoline (either by a signal being delivered or by 4790 the signal handler returning). Just single-step until the 4791 inferior leaves the trampoline (either by calling the handler 4792 or returning). */ 4793 keep_going (ecs); 4794 return; 4795 } 4796 4797 /* Check for subroutine calls. The check for the current frame 4798 equalling the step ID is not necessary - the check of the 4799 previous frame's ID is sufficient - but it is a common case and 4800 cheaper than checking the previous frame's ID. 4801 4802 NOTE: frame_id_eq will never report two invalid frame IDs as 4803 being equal, so to get into this block, both the current and 4804 previous frame must have valid frame IDs. */ 4805 /* The outer_frame_id check is a heuristic to detect stepping 4806 through startup code. If we step over an instruction which 4807 sets the stack pointer from an invalid value to a valid value, 4808 we may detect that as a subroutine call from the mythical 4809 "outermost" function. This could be fixed by marking 4810 outermost frames as !stack_p,code_p,special_p. Then the 4811 initial outermost frame, before sp was valid, would 4812 have code_addr == &_start. See the comment in frame_id_eq 4813 for more. */ 4814 if (!frame_id_eq (get_stack_frame_id (frame), 4815 ecs->event_thread->control.step_stack_frame_id) 4816 && (frame_id_eq (frame_unwind_caller_id (get_current_frame ()), 4817 ecs->event_thread->control.step_stack_frame_id) 4818 && (!frame_id_eq (ecs->event_thread->control.step_stack_frame_id, 4819 outer_frame_id) 4820 || step_start_function != find_pc_function (stop_pc)))) 4821 { 4822 CORE_ADDR real_stop_pc; 4823 4824 if (debug_infrun) 4825 fprintf_unfiltered (gdb_stdlog, "infrun: stepped into subroutine\n"); 4826 4827 if ((ecs->event_thread->control.step_over_calls == STEP_OVER_NONE) 4828 || ((ecs->event_thread->control.step_range_end == 1) 4829 && in_prologue (gdbarch, ecs->event_thread->prev_pc, 4830 ecs->stop_func_start))) 4831 { 4832 /* I presume that step_over_calls is only 0 when we're 4833 supposed to be stepping at the assembly language level 4834 ("stepi"). Just stop. */ 4835 /* Also, maybe we just did a "nexti" inside a prolog, so we 4836 thought it was a subroutine call but it was not. Stop as 4837 well. FENN */ 4838 /* And this works the same backward as frontward. MVS */ 4839 ecs->event_thread->control.stop_step = 1; 4840 print_end_stepping_range_reason (); 4841 stop_stepping (ecs); 4842 return; 4843 } 4844 4845 /* Reverse stepping through solib trampolines. */ 4846 4847 if (execution_direction == EXEC_REVERSE 4848 && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE 4849 && (gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc) 4850 || (ecs->stop_func_start == 0 4851 && in_solib_dynsym_resolve_code (stop_pc)))) 4852 { 4853 /* Any solib trampoline code can be handled in reverse 4854 by simply continuing to single-step. We have already 4855 executed the solib function (backwards), and a few 4856 steps will take us back through the trampoline to the 4857 caller. */ 4858 keep_going (ecs); 4859 return; 4860 } 4861 4862 if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL) 4863 { 4864 /* We're doing a "next". 4865 4866 Normal (forward) execution: set a breakpoint at the 4867 callee's return address (the address at which the caller 4868 will resume). 4869 4870 Reverse (backward) execution. set the step-resume 4871 breakpoint at the start of the function that we just 4872 stepped into (backwards), and continue to there. When we 4873 get there, we'll need to single-step back to the caller. */ 4874 4875 if (execution_direction == EXEC_REVERSE) 4876 { 4877 struct symtab_and_line sr_sal; 4878 4879 /* Normal function call return (static or dynamic). */ 4880 init_sal (&sr_sal); 4881 sr_sal.pc = ecs->stop_func_start; 4882 sr_sal.pspace = get_frame_program_space (frame); 4883 insert_step_resume_breakpoint_at_sal (gdbarch, 4884 sr_sal, null_frame_id); 4885 } 4886 else 4887 insert_step_resume_breakpoint_at_caller (frame); 4888 4889 keep_going (ecs); 4890 return; 4891 } 4892 4893 /* If we are in a function call trampoline (a stub between the 4894 calling routine and the real function), locate the real 4895 function. That's what tells us (a) whether we want to step 4896 into it at all, and (b) what prologue we want to run to the 4897 end of, if we do step into it. */ 4898 real_stop_pc = skip_language_trampoline (frame, stop_pc); 4899 if (real_stop_pc == 0) 4900 real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc); 4901 if (real_stop_pc != 0) 4902 ecs->stop_func_start = real_stop_pc; 4903 4904 if (real_stop_pc != 0 && in_solib_dynsym_resolve_code (real_stop_pc)) 4905 { 4906 struct symtab_and_line sr_sal; 4907 4908 init_sal (&sr_sal); 4909 sr_sal.pc = ecs->stop_func_start; 4910 sr_sal.pspace = get_frame_program_space (frame); 4911 4912 insert_step_resume_breakpoint_at_sal (gdbarch, 4913 sr_sal, null_frame_id); 4914 keep_going (ecs); 4915 return; 4916 } 4917 4918 /* If we have line number information for the function we are 4919 thinking of stepping into and the function isn't on the skip 4920 list, step into it. 4921 4922 If there are several symtabs at that PC (e.g. with include 4923 files), just want to know whether *any* of them have line 4924 numbers. find_pc_line handles this. */ 4925 { 4926 struct symtab_and_line tmp_sal; 4927 4928 tmp_sal = find_pc_line (ecs->stop_func_start, 0); 4929 if (tmp_sal.line != 0 4930 && !function_pc_is_marked_for_skip (ecs->stop_func_start)) 4931 { 4932 if (execution_direction == EXEC_REVERSE) 4933 handle_step_into_function_backward (gdbarch, ecs); 4934 else 4935 handle_step_into_function (gdbarch, ecs); 4936 return; 4937 } 4938 } 4939 4940 /* If we have no line number and the step-stop-if-no-debug is 4941 set, we stop the step so that the user has a chance to switch 4942 in assembly mode. */ 4943 if (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE 4944 && step_stop_if_no_debug) 4945 { 4946 ecs->event_thread->control.stop_step = 1; 4947 print_end_stepping_range_reason (); 4948 stop_stepping (ecs); 4949 return; 4950 } 4951 4952 if (execution_direction == EXEC_REVERSE) 4953 { 4954 /* Set a breakpoint at callee's start address. 4955 From there we can step once and be back in the caller. */ 4956 struct symtab_and_line sr_sal; 4957 4958 init_sal (&sr_sal); 4959 sr_sal.pc = ecs->stop_func_start; 4960 sr_sal.pspace = get_frame_program_space (frame); 4961 insert_step_resume_breakpoint_at_sal (gdbarch, 4962 sr_sal, null_frame_id); 4963 } 4964 else 4965 /* Set a breakpoint at callee's return address (the address 4966 at which the caller will resume). */ 4967 insert_step_resume_breakpoint_at_caller (frame); 4968 4969 keep_going (ecs); 4970 return; 4971 } 4972 4973 /* Reverse stepping through solib trampolines. */ 4974 4975 if (execution_direction == EXEC_REVERSE 4976 && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE) 4977 { 4978 if (gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc) 4979 || (ecs->stop_func_start == 0 4980 && in_solib_dynsym_resolve_code (stop_pc))) 4981 { 4982 /* Any solib trampoline code can be handled in reverse 4983 by simply continuing to single-step. We have already 4984 executed the solib function (backwards), and a few 4985 steps will take us back through the trampoline to the 4986 caller. */ 4987 keep_going (ecs); 4988 return; 4989 } 4990 else if (in_solib_dynsym_resolve_code (stop_pc)) 4991 { 4992 /* Stepped backward into the solib dynsym resolver. 4993 Set a breakpoint at its start and continue, then 4994 one more step will take us out. */ 4995 struct symtab_and_line sr_sal; 4996 4997 init_sal (&sr_sal); 4998 sr_sal.pc = ecs->stop_func_start; 4999 sr_sal.pspace = get_frame_program_space (frame); 5000 insert_step_resume_breakpoint_at_sal (gdbarch, 5001 sr_sal, null_frame_id); 5002 keep_going (ecs); 5003 return; 5004 } 5005 } 5006 5007 /* If we're in the return path from a shared library trampoline, 5008 we want to proceed through the trampoline when stepping. */ 5009 if (gdbarch_in_solib_return_trampoline (gdbarch, 5010 stop_pc, ecs->stop_func_name)) 5011 { 5012 /* Determine where this trampoline returns. */ 5013 CORE_ADDR real_stop_pc; 5014 5015 real_stop_pc = gdbarch_skip_trampoline_code (gdbarch, frame, stop_pc); 5016 5017 if (debug_infrun) 5018 fprintf_unfiltered (gdb_stdlog, 5019 "infrun: stepped into solib return tramp\n"); 5020 5021 /* Only proceed through if we know where it's going. */ 5022 if (real_stop_pc) 5023 { 5024 /* And put the step-breakpoint there and go until there. */ 5025 struct symtab_and_line sr_sal; 5026 5027 init_sal (&sr_sal); /* initialize to zeroes */ 5028 sr_sal.pc = real_stop_pc; 5029 sr_sal.section = find_pc_overlay (sr_sal.pc); 5030 sr_sal.pspace = get_frame_program_space (frame); 5031 5032 /* Do not specify what the fp should be when we stop since 5033 on some machines the prologue is where the new fp value 5034 is established. */ 5035 insert_step_resume_breakpoint_at_sal (gdbarch, 5036 sr_sal, null_frame_id); 5037 5038 /* Restart without fiddling with the step ranges or 5039 other state. */ 5040 keep_going (ecs); 5041 return; 5042 } 5043 } 5044 5045 stop_pc_sal = find_pc_line (stop_pc, 0); 5046 5047 /* NOTE: tausq/2004-05-24: This if block used to be done before all 5048 the trampoline processing logic, however, there are some trampolines 5049 that have no names, so we should do trampoline handling first. */ 5050 if (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE 5051 && ecs->stop_func_name == NULL 5052 && stop_pc_sal.line == 0) 5053 { 5054 if (debug_infrun) 5055 fprintf_unfiltered (gdb_stdlog, 5056 "infrun: stepped into undebuggable function\n"); 5057 5058 /* The inferior just stepped into, or returned to, an 5059 undebuggable function (where there is no debugging information 5060 and no line number corresponding to the address where the 5061 inferior stopped). Since we want to skip this kind of code, 5062 we keep going until the inferior returns from this 5063 function - unless the user has asked us not to (via 5064 set step-mode) or we no longer know how to get back 5065 to the call site. */ 5066 if (step_stop_if_no_debug 5067 || !frame_id_p (frame_unwind_caller_id (frame))) 5068 { 5069 /* If we have no line number and the step-stop-if-no-debug 5070 is set, we stop the step so that the user has a chance to 5071 switch in assembly mode. */ 5072 ecs->event_thread->control.stop_step = 1; 5073 print_end_stepping_range_reason (); 5074 stop_stepping (ecs); 5075 return; 5076 } 5077 else 5078 { 5079 /* Set a breakpoint at callee's return address (the address 5080 at which the caller will resume). */ 5081 insert_step_resume_breakpoint_at_caller (frame); 5082 keep_going (ecs); 5083 return; 5084 } 5085 } 5086 5087 if (ecs->event_thread->control.step_range_end == 1) 5088 { 5089 /* It is stepi or nexti. We always want to stop stepping after 5090 one instruction. */ 5091 if (debug_infrun) 5092 fprintf_unfiltered (gdb_stdlog, "infrun: stepi/nexti\n"); 5093 ecs->event_thread->control.stop_step = 1; 5094 print_end_stepping_range_reason (); 5095 stop_stepping (ecs); 5096 return; 5097 } 5098 5099 if (stop_pc_sal.line == 0) 5100 { 5101 /* We have no line number information. That means to stop 5102 stepping (does this always happen right after one instruction, 5103 when we do "s" in a function with no line numbers, 5104 or can this happen as a result of a return or longjmp?). */ 5105 if (debug_infrun) 5106 fprintf_unfiltered (gdb_stdlog, "infrun: no line number info\n"); 5107 ecs->event_thread->control.stop_step = 1; 5108 print_end_stepping_range_reason (); 5109 stop_stepping (ecs); 5110 return; 5111 } 5112 5113 /* Look for "calls" to inlined functions, part one. If the inline 5114 frame machinery detected some skipped call sites, we have entered 5115 a new inline function. */ 5116 5117 if (frame_id_eq (get_frame_id (get_current_frame ()), 5118 ecs->event_thread->control.step_frame_id) 5119 && inline_skipped_frames (ecs->ptid)) 5120 { 5121 struct symtab_and_line call_sal; 5122 5123 if (debug_infrun) 5124 fprintf_unfiltered (gdb_stdlog, 5125 "infrun: stepped into inlined function\n"); 5126 5127 find_frame_sal (get_current_frame (), &call_sal); 5128 5129 if (ecs->event_thread->control.step_over_calls != STEP_OVER_ALL) 5130 { 5131 /* For "step", we're going to stop. But if the call site 5132 for this inlined function is on the same source line as 5133 we were previously stepping, go down into the function 5134 first. Otherwise stop at the call site. */ 5135 5136 if (call_sal.line == ecs->event_thread->current_line 5137 && call_sal.symtab == ecs->event_thread->current_symtab) 5138 step_into_inline_frame (ecs->ptid); 5139 5140 ecs->event_thread->control.stop_step = 1; 5141 print_end_stepping_range_reason (); 5142 stop_stepping (ecs); 5143 return; 5144 } 5145 else 5146 { 5147 /* For "next", we should stop at the call site if it is on a 5148 different source line. Otherwise continue through the 5149 inlined function. */ 5150 if (call_sal.line == ecs->event_thread->current_line 5151 && call_sal.symtab == ecs->event_thread->current_symtab) 5152 keep_going (ecs); 5153 else 5154 { 5155 ecs->event_thread->control.stop_step = 1; 5156 print_end_stepping_range_reason (); 5157 stop_stepping (ecs); 5158 } 5159 return; 5160 } 5161 } 5162 5163 /* Look for "calls" to inlined functions, part two. If we are still 5164 in the same real function we were stepping through, but we have 5165 to go further up to find the exact frame ID, we are stepping 5166 through a more inlined call beyond its call site. */ 5167 5168 if (get_frame_type (get_current_frame ()) == INLINE_FRAME 5169 && !frame_id_eq (get_frame_id (get_current_frame ()), 5170 ecs->event_thread->control.step_frame_id) 5171 && stepped_in_from (get_current_frame (), 5172 ecs->event_thread->control.step_frame_id)) 5173 { 5174 if (debug_infrun) 5175 fprintf_unfiltered (gdb_stdlog, 5176 "infrun: stepping through inlined function\n"); 5177 5178 if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL) 5179 keep_going (ecs); 5180 else 5181 { 5182 ecs->event_thread->control.stop_step = 1; 5183 print_end_stepping_range_reason (); 5184 stop_stepping (ecs); 5185 } 5186 return; 5187 } 5188 5189 if ((stop_pc == stop_pc_sal.pc) 5190 && (ecs->event_thread->current_line != stop_pc_sal.line 5191 || ecs->event_thread->current_symtab != stop_pc_sal.symtab)) 5192 { 5193 /* We are at the start of a different line. So stop. Note that 5194 we don't stop if we step into the middle of a different line. 5195 That is said to make things like for (;;) statements work 5196 better. */ 5197 if (debug_infrun) 5198 fprintf_unfiltered (gdb_stdlog, 5199 "infrun: stepped to a different line\n"); 5200 ecs->event_thread->control.stop_step = 1; 5201 print_end_stepping_range_reason (); 5202 stop_stepping (ecs); 5203 return; 5204 } 5205 5206 /* We aren't done stepping. 5207 5208 Optimize by setting the stepping range to the line. 5209 (We might not be in the original line, but if we entered a 5210 new line in mid-statement, we continue stepping. This makes 5211 things like for(;;) statements work better.) */ 5212 5213 ecs->event_thread->control.step_range_start = stop_pc_sal.pc; 5214 ecs->event_thread->control.step_range_end = stop_pc_sal.end; 5215 set_step_info (frame, stop_pc_sal); 5216 5217 if (debug_infrun) 5218 fprintf_unfiltered (gdb_stdlog, "infrun: keep going\n"); 5219 keep_going (ecs); 5220 } 5221 5222 /* Is thread TP in the middle of single-stepping? */ 5223 5224 static int 5225 currently_stepping (struct thread_info *tp) 5226 { 5227 return ((tp->control.step_range_end 5228 && tp->control.step_resume_breakpoint == NULL) 5229 || tp->control.trap_expected 5230 || bpstat_should_step ()); 5231 } 5232 5233 /* Returns true if any thread *but* the one passed in "data" is in the 5234 middle of stepping or of handling a "next". */ 5235 5236 static int 5237 currently_stepping_or_nexting_callback (struct thread_info *tp, void *data) 5238 { 5239 if (tp == data) 5240 return 0; 5241 5242 return (tp->control.step_range_end 5243 || tp->control.trap_expected); 5244 } 5245 5246 /* Inferior has stepped into a subroutine call with source code that 5247 we should not step over. Do step to the first line of code in 5248 it. */ 5249 5250 static void 5251 handle_step_into_function (struct gdbarch *gdbarch, 5252 struct execution_control_state *ecs) 5253 { 5254 struct symtab *s; 5255 struct symtab_and_line stop_func_sal, sr_sal; 5256 5257 fill_in_stop_func (gdbarch, ecs); 5258 5259 s = find_pc_symtab (stop_pc); 5260 if (s && s->language != language_asm) 5261 ecs->stop_func_start = gdbarch_skip_prologue (gdbarch, 5262 ecs->stop_func_start); 5263 5264 stop_func_sal = find_pc_line (ecs->stop_func_start, 0); 5265 /* Use the step_resume_break to step until the end of the prologue, 5266 even if that involves jumps (as it seems to on the vax under 5267 4.2). */ 5268 /* If the prologue ends in the middle of a source line, continue to 5269 the end of that source line (if it is still within the function). 5270 Otherwise, just go to end of prologue. */ 5271 if (stop_func_sal.end 5272 && stop_func_sal.pc != ecs->stop_func_start 5273 && stop_func_sal.end < ecs->stop_func_end) 5274 ecs->stop_func_start = stop_func_sal.end; 5275 5276 /* Architectures which require breakpoint adjustment might not be able 5277 to place a breakpoint at the computed address. If so, the test 5278 ``ecs->stop_func_start == stop_pc'' will never succeed. Adjust 5279 ecs->stop_func_start to an address at which a breakpoint may be 5280 legitimately placed. 5281 5282 Note: kevinb/2004-01-19: On FR-V, if this adjustment is not 5283 made, GDB will enter an infinite loop when stepping through 5284 optimized code consisting of VLIW instructions which contain 5285 subinstructions corresponding to different source lines. On 5286 FR-V, it's not permitted to place a breakpoint on any but the 5287 first subinstruction of a VLIW instruction. When a breakpoint is 5288 set, GDB will adjust the breakpoint address to the beginning of 5289 the VLIW instruction. Thus, we need to make the corresponding 5290 adjustment here when computing the stop address. */ 5291 5292 if (gdbarch_adjust_breakpoint_address_p (gdbarch)) 5293 { 5294 ecs->stop_func_start 5295 = gdbarch_adjust_breakpoint_address (gdbarch, 5296 ecs->stop_func_start); 5297 } 5298 5299 if (ecs->stop_func_start == stop_pc) 5300 { 5301 /* We are already there: stop now. */ 5302 ecs->event_thread->control.stop_step = 1; 5303 print_end_stepping_range_reason (); 5304 stop_stepping (ecs); 5305 return; 5306 } 5307 else 5308 { 5309 /* Put the step-breakpoint there and go until there. */ 5310 init_sal (&sr_sal); /* initialize to zeroes */ 5311 sr_sal.pc = ecs->stop_func_start; 5312 sr_sal.section = find_pc_overlay (ecs->stop_func_start); 5313 sr_sal.pspace = get_frame_program_space (get_current_frame ()); 5314 5315 /* Do not specify what the fp should be when we stop since on 5316 some machines the prologue is where the new fp value is 5317 established. */ 5318 insert_step_resume_breakpoint_at_sal (gdbarch, sr_sal, null_frame_id); 5319 5320 /* And make sure stepping stops right away then. */ 5321 ecs->event_thread->control.step_range_end 5322 = ecs->event_thread->control.step_range_start; 5323 } 5324 keep_going (ecs); 5325 } 5326 5327 /* Inferior has stepped backward into a subroutine call with source 5328 code that we should not step over. Do step to the beginning of the 5329 last line of code in it. */ 5330 5331 static void 5332 handle_step_into_function_backward (struct gdbarch *gdbarch, 5333 struct execution_control_state *ecs) 5334 { 5335 struct symtab *s; 5336 struct symtab_and_line stop_func_sal; 5337 5338 fill_in_stop_func (gdbarch, ecs); 5339 5340 s = find_pc_symtab (stop_pc); 5341 if (s && s->language != language_asm) 5342 ecs->stop_func_start = gdbarch_skip_prologue (gdbarch, 5343 ecs->stop_func_start); 5344 5345 stop_func_sal = find_pc_line (stop_pc, 0); 5346 5347 /* OK, we're just going to keep stepping here. */ 5348 if (stop_func_sal.pc == stop_pc) 5349 { 5350 /* We're there already. Just stop stepping now. */ 5351 ecs->event_thread->control.stop_step = 1; 5352 print_end_stepping_range_reason (); 5353 stop_stepping (ecs); 5354 } 5355 else 5356 { 5357 /* Else just reset the step range and keep going. 5358 No step-resume breakpoint, they don't work for 5359 epilogues, which can have multiple entry paths. */ 5360 ecs->event_thread->control.step_range_start = stop_func_sal.pc; 5361 ecs->event_thread->control.step_range_end = stop_func_sal.end; 5362 keep_going (ecs); 5363 } 5364 return; 5365 } 5366 5367 /* Insert a "step-resume breakpoint" at SR_SAL with frame ID SR_ID. 5368 This is used to both functions and to skip over code. */ 5369 5370 static void 5371 insert_step_resume_breakpoint_at_sal_1 (struct gdbarch *gdbarch, 5372 struct symtab_and_line sr_sal, 5373 struct frame_id sr_id, 5374 enum bptype sr_type) 5375 { 5376 /* There should never be more than one step-resume or longjmp-resume 5377 breakpoint per thread, so we should never be setting a new 5378 step_resume_breakpoint when one is already active. */ 5379 gdb_assert (inferior_thread ()->control.step_resume_breakpoint == NULL); 5380 gdb_assert (sr_type == bp_step_resume || sr_type == bp_hp_step_resume); 5381 5382 if (debug_infrun) 5383 fprintf_unfiltered (gdb_stdlog, 5384 "infrun: inserting step-resume breakpoint at %s\n", 5385 paddress (gdbarch, sr_sal.pc)); 5386 5387 inferior_thread ()->control.step_resume_breakpoint 5388 = set_momentary_breakpoint (gdbarch, sr_sal, sr_id, sr_type); 5389 } 5390 5391 void 5392 insert_step_resume_breakpoint_at_sal (struct gdbarch *gdbarch, 5393 struct symtab_and_line sr_sal, 5394 struct frame_id sr_id) 5395 { 5396 insert_step_resume_breakpoint_at_sal_1 (gdbarch, 5397 sr_sal, sr_id, 5398 bp_step_resume); 5399 } 5400 5401 /* Insert a "high-priority step-resume breakpoint" at RETURN_FRAME.pc. 5402 This is used to skip a potential signal handler. 5403 5404 This is called with the interrupted function's frame. The signal 5405 handler, when it returns, will resume the interrupted function at 5406 RETURN_FRAME.pc. */ 5407 5408 static void 5409 insert_hp_step_resume_breakpoint_at_frame (struct frame_info *return_frame) 5410 { 5411 struct symtab_and_line sr_sal; 5412 struct gdbarch *gdbarch; 5413 5414 gdb_assert (return_frame != NULL); 5415 init_sal (&sr_sal); /* initialize to zeros */ 5416 5417 gdbarch = get_frame_arch (return_frame); 5418 sr_sal.pc = gdbarch_addr_bits_remove (gdbarch, get_frame_pc (return_frame)); 5419 sr_sal.section = find_pc_overlay (sr_sal.pc); 5420 sr_sal.pspace = get_frame_program_space (return_frame); 5421 5422 insert_step_resume_breakpoint_at_sal_1 (gdbarch, sr_sal, 5423 get_stack_frame_id (return_frame), 5424 bp_hp_step_resume); 5425 } 5426 5427 /* Insert a "step-resume breakpoint" at the previous frame's PC. This 5428 is used to skip a function after stepping into it (for "next" or if 5429 the called function has no debugging information). 5430 5431 The current function has almost always been reached by single 5432 stepping a call or return instruction. NEXT_FRAME belongs to the 5433 current function, and the breakpoint will be set at the caller's 5434 resume address. 5435 5436 This is a separate function rather than reusing 5437 insert_hp_step_resume_breakpoint_at_frame in order to avoid 5438 get_prev_frame, which may stop prematurely (see the implementation 5439 of frame_unwind_caller_id for an example). */ 5440 5441 static void 5442 insert_step_resume_breakpoint_at_caller (struct frame_info *next_frame) 5443 { 5444 struct symtab_and_line sr_sal; 5445 struct gdbarch *gdbarch; 5446 5447 /* We shouldn't have gotten here if we don't know where the call site 5448 is. */ 5449 gdb_assert (frame_id_p (frame_unwind_caller_id (next_frame))); 5450 5451 init_sal (&sr_sal); /* initialize to zeros */ 5452 5453 gdbarch = frame_unwind_caller_arch (next_frame); 5454 sr_sal.pc = gdbarch_addr_bits_remove (gdbarch, 5455 frame_unwind_caller_pc (next_frame)); 5456 sr_sal.section = find_pc_overlay (sr_sal.pc); 5457 sr_sal.pspace = frame_unwind_program_space (next_frame); 5458 5459 insert_step_resume_breakpoint_at_sal (gdbarch, sr_sal, 5460 frame_unwind_caller_id (next_frame)); 5461 } 5462 5463 /* Insert a "longjmp-resume" breakpoint at PC. This is used to set a 5464 new breakpoint at the target of a jmp_buf. The handling of 5465 longjmp-resume uses the same mechanisms used for handling 5466 "step-resume" breakpoints. */ 5467 5468 static void 5469 insert_longjmp_resume_breakpoint (struct gdbarch *gdbarch, CORE_ADDR pc) 5470 { 5471 /* There should never be more than one step-resume or longjmp-resume 5472 breakpoint per thread, so we should never be setting a new 5473 longjmp_resume_breakpoint when one is already active. */ 5474 gdb_assert (inferior_thread ()->control.step_resume_breakpoint == NULL); 5475 5476 if (debug_infrun) 5477 fprintf_unfiltered (gdb_stdlog, 5478 "infrun: inserting longjmp-resume breakpoint at %s\n", 5479 paddress (gdbarch, pc)); 5480 5481 inferior_thread ()->control.step_resume_breakpoint = 5482 set_momentary_breakpoint_at_pc (gdbarch, pc, bp_longjmp_resume); 5483 } 5484 5485 /* Insert an exception resume breakpoint. TP is the thread throwing 5486 the exception. The block B is the block of the unwinder debug hook 5487 function. FRAME is the frame corresponding to the call to this 5488 function. SYM is the symbol of the function argument holding the 5489 target PC of the exception. */ 5490 5491 static void 5492 insert_exception_resume_breakpoint (struct thread_info *tp, 5493 struct block *b, 5494 struct frame_info *frame, 5495 struct symbol *sym) 5496 { 5497 struct gdb_exception e; 5498 5499 /* We want to ignore errors here. */ 5500 TRY_CATCH (e, RETURN_MASK_ERROR) 5501 { 5502 struct symbol *vsym; 5503 struct value *value; 5504 CORE_ADDR handler; 5505 struct breakpoint *bp; 5506 5507 vsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym), b, VAR_DOMAIN, NULL); 5508 value = read_var_value (vsym, frame); 5509 /* If the value was optimized out, revert to the old behavior. */ 5510 if (! value_optimized_out (value)) 5511 { 5512 handler = value_as_address (value); 5513 5514 if (debug_infrun) 5515 fprintf_unfiltered (gdb_stdlog, 5516 "infrun: exception resume at %lx\n", 5517 (unsigned long) handler); 5518 5519 bp = set_momentary_breakpoint_at_pc (get_frame_arch (frame), 5520 handler, bp_exception_resume); 5521 bp->thread = tp->num; 5522 inferior_thread ()->control.exception_resume_breakpoint = bp; 5523 } 5524 } 5525 } 5526 5527 /* This is called when an exception has been intercepted. Check to 5528 see whether the exception's destination is of interest, and if so, 5529 set an exception resume breakpoint there. */ 5530 5531 static void 5532 check_exception_resume (struct execution_control_state *ecs, 5533 struct frame_info *frame, struct symbol *func) 5534 { 5535 struct gdb_exception e; 5536 5537 TRY_CATCH (e, RETURN_MASK_ERROR) 5538 { 5539 struct block *b; 5540 struct dict_iterator iter; 5541 struct symbol *sym; 5542 int argno = 0; 5543 5544 /* The exception breakpoint is a thread-specific breakpoint on 5545 the unwinder's debug hook, declared as: 5546 5547 void _Unwind_DebugHook (void *cfa, void *handler); 5548 5549 The CFA argument indicates the frame to which control is 5550 about to be transferred. HANDLER is the destination PC. 5551 5552 We ignore the CFA and set a temporary breakpoint at HANDLER. 5553 This is not extremely efficient but it avoids issues in gdb 5554 with computing the DWARF CFA, and it also works even in weird 5555 cases such as throwing an exception from inside a signal 5556 handler. */ 5557 5558 b = SYMBOL_BLOCK_VALUE (func); 5559 ALL_BLOCK_SYMBOLS (b, iter, sym) 5560 { 5561 if (!SYMBOL_IS_ARGUMENT (sym)) 5562 continue; 5563 5564 if (argno == 0) 5565 ++argno; 5566 else 5567 { 5568 insert_exception_resume_breakpoint (ecs->event_thread, 5569 b, frame, sym); 5570 break; 5571 } 5572 } 5573 } 5574 } 5575 5576 static void 5577 stop_stepping (struct execution_control_state *ecs) 5578 { 5579 if (debug_infrun) 5580 fprintf_unfiltered (gdb_stdlog, "infrun: stop_stepping\n"); 5581 5582 /* Let callers know we don't want to wait for the inferior anymore. */ 5583 ecs->wait_some_more = 0; 5584 } 5585 5586 /* This function handles various cases where we need to continue 5587 waiting for the inferior. */ 5588 /* (Used to be the keep_going: label in the old wait_for_inferior). */ 5589 5590 static void 5591 keep_going (struct execution_control_state *ecs) 5592 { 5593 /* Make sure normal_stop is called if we get a QUIT handled before 5594 reaching resume. */ 5595 struct cleanup *old_cleanups = make_cleanup (resume_cleanups, 0); 5596 5597 /* Save the pc before execution, to compare with pc after stop. */ 5598 ecs->event_thread->prev_pc 5599 = regcache_read_pc (get_thread_regcache (ecs->ptid)); 5600 5601 /* If we did not do break;, it means we should keep running the 5602 inferior and not return to debugger. */ 5603 5604 if (ecs->event_thread->control.trap_expected 5605 && ecs->event_thread->suspend.stop_signal != TARGET_SIGNAL_TRAP) 5606 { 5607 /* We took a signal (which we are supposed to pass through to 5608 the inferior, else we'd not get here) and we haven't yet 5609 gotten our trap. Simply continue. */ 5610 5611 discard_cleanups (old_cleanups); 5612 resume (currently_stepping (ecs->event_thread), 5613 ecs->event_thread->suspend.stop_signal); 5614 } 5615 else 5616 { 5617 /* Either the trap was not expected, but we are continuing 5618 anyway (the user asked that this signal be passed to the 5619 child) 5620 -- or -- 5621 The signal was SIGTRAP, e.g. it was our signal, but we 5622 decided we should resume from it. 5623 5624 We're going to run this baby now! 5625 5626 Note that insert_breakpoints won't try to re-insert 5627 already inserted breakpoints. Therefore, we don't 5628 care if breakpoints were already inserted, or not. */ 5629 5630 if (ecs->event_thread->stepping_over_breakpoint) 5631 { 5632 struct regcache *thread_regcache = get_thread_regcache (ecs->ptid); 5633 5634 if (!use_displaced_stepping (get_regcache_arch (thread_regcache))) 5635 /* Since we can't do a displaced step, we have to remove 5636 the breakpoint while we step it. To keep things 5637 simple, we remove them all. */ 5638 remove_breakpoints (); 5639 } 5640 else 5641 { 5642 struct gdb_exception e; 5643 5644 /* Stop stepping when inserting breakpoints 5645 has failed. */ 5646 TRY_CATCH (e, RETURN_MASK_ERROR) 5647 { 5648 insert_breakpoints (); 5649 } 5650 if (e.reason < 0) 5651 { 5652 exception_print (gdb_stderr, e); 5653 stop_stepping (ecs); 5654 return; 5655 } 5656 } 5657 5658 ecs->event_thread->control.trap_expected 5659 = ecs->event_thread->stepping_over_breakpoint; 5660 5661 /* Do not deliver SIGNAL_TRAP (except when the user explicitly 5662 specifies that such a signal should be delivered to the 5663 target program). 5664 5665 Typically, this would occure when a user is debugging a 5666 target monitor on a simulator: the target monitor sets a 5667 breakpoint; the simulator encounters this break-point and 5668 halts the simulation handing control to GDB; GDB, noteing 5669 that the break-point isn't valid, returns control back to the 5670 simulator; the simulator then delivers the hardware 5671 equivalent of a SIGNAL_TRAP to the program being debugged. */ 5672 5673 if (ecs->event_thread->suspend.stop_signal == TARGET_SIGNAL_TRAP 5674 && !signal_program[ecs->event_thread->suspend.stop_signal]) 5675 ecs->event_thread->suspend.stop_signal = TARGET_SIGNAL_0; 5676 5677 discard_cleanups (old_cleanups); 5678 resume (currently_stepping (ecs->event_thread), 5679 ecs->event_thread->suspend.stop_signal); 5680 } 5681 5682 prepare_to_wait (ecs); 5683 } 5684 5685 /* This function normally comes after a resume, before 5686 handle_inferior_event exits. It takes care of any last bits of 5687 housekeeping, and sets the all-important wait_some_more flag. */ 5688 5689 static void 5690 prepare_to_wait (struct execution_control_state *ecs) 5691 { 5692 if (debug_infrun) 5693 fprintf_unfiltered (gdb_stdlog, "infrun: prepare_to_wait\n"); 5694 5695 /* This is the old end of the while loop. Let everybody know we 5696 want to wait for the inferior some more and get called again 5697 soon. */ 5698 ecs->wait_some_more = 1; 5699 } 5700 5701 /* Several print_*_reason functions to print why the inferior has stopped. 5702 We always print something when the inferior exits, or receives a signal. 5703 The rest of the cases are dealt with later on in normal_stop and 5704 print_it_typical. Ideally there should be a call to one of these 5705 print_*_reason functions functions from handle_inferior_event each time 5706 stop_stepping is called. */ 5707 5708 /* Print why the inferior has stopped. 5709 We are done with a step/next/si/ni command, print why the inferior has 5710 stopped. For now print nothing. Print a message only if not in the middle 5711 of doing a "step n" operation for n > 1. */ 5712 5713 static void 5714 print_end_stepping_range_reason (void) 5715 { 5716 if ((!inferior_thread ()->step_multi 5717 || !inferior_thread ()->control.stop_step) 5718 && ui_out_is_mi_like_p (current_uiout)) 5719 ui_out_field_string (current_uiout, "reason", 5720 async_reason_lookup (EXEC_ASYNC_END_STEPPING_RANGE)); 5721 } 5722 5723 /* The inferior was terminated by a signal, print why it stopped. */ 5724 5725 static void 5726 print_signal_exited_reason (enum target_signal siggnal) 5727 { 5728 struct ui_out *uiout = current_uiout; 5729 5730 annotate_signalled (); 5731 if (ui_out_is_mi_like_p (uiout)) 5732 ui_out_field_string 5733 (uiout, "reason", async_reason_lookup (EXEC_ASYNC_EXITED_SIGNALLED)); 5734 ui_out_text (uiout, "\nProgram terminated with signal "); 5735 annotate_signal_name (); 5736 ui_out_field_string (uiout, "signal-name", 5737 target_signal_to_name (siggnal)); 5738 annotate_signal_name_end (); 5739 ui_out_text (uiout, ", "); 5740 annotate_signal_string (); 5741 ui_out_field_string (uiout, "signal-meaning", 5742 target_signal_to_string (siggnal)); 5743 annotate_signal_string_end (); 5744 ui_out_text (uiout, ".\n"); 5745 ui_out_text (uiout, "The program no longer exists.\n"); 5746 } 5747 5748 /* The inferior program is finished, print why it stopped. */ 5749 5750 static void 5751 print_exited_reason (int exitstatus) 5752 { 5753 struct inferior *inf = current_inferior (); 5754 const char *pidstr = target_pid_to_str (pid_to_ptid (inf->pid)); 5755 struct ui_out *uiout = current_uiout; 5756 5757 annotate_exited (exitstatus); 5758 if (exitstatus) 5759 { 5760 if (ui_out_is_mi_like_p (uiout)) 5761 ui_out_field_string (uiout, "reason", 5762 async_reason_lookup (EXEC_ASYNC_EXITED)); 5763 ui_out_text (uiout, "[Inferior "); 5764 ui_out_text (uiout, plongest (inf->num)); 5765 ui_out_text (uiout, " ("); 5766 ui_out_text (uiout, pidstr); 5767 ui_out_text (uiout, ") exited with code "); 5768 ui_out_field_fmt (uiout, "exit-code", "0%o", (unsigned int) exitstatus); 5769 ui_out_text (uiout, "]\n"); 5770 } 5771 else 5772 { 5773 if (ui_out_is_mi_like_p (uiout)) 5774 ui_out_field_string 5775 (uiout, "reason", async_reason_lookup (EXEC_ASYNC_EXITED_NORMALLY)); 5776 ui_out_text (uiout, "[Inferior "); 5777 ui_out_text (uiout, plongest (inf->num)); 5778 ui_out_text (uiout, " ("); 5779 ui_out_text (uiout, pidstr); 5780 ui_out_text (uiout, ") exited normally]\n"); 5781 } 5782 /* Support the --return-child-result option. */ 5783 return_child_result_value = exitstatus; 5784 } 5785 5786 /* Signal received, print why the inferior has stopped. The signal table 5787 tells us to print about it. */ 5788 5789 static void 5790 print_signal_received_reason (enum target_signal siggnal) 5791 { 5792 struct ui_out *uiout = current_uiout; 5793 5794 annotate_signal (); 5795 5796 if (siggnal == TARGET_SIGNAL_0 && !ui_out_is_mi_like_p (uiout)) 5797 { 5798 struct thread_info *t = inferior_thread (); 5799 5800 ui_out_text (uiout, "\n["); 5801 ui_out_field_string (uiout, "thread-name", 5802 target_pid_to_str (t->ptid)); 5803 ui_out_field_fmt (uiout, "thread-id", "] #%d", t->num); 5804 ui_out_text (uiout, " stopped"); 5805 } 5806 else 5807 { 5808 ui_out_text (uiout, "\nProgram received signal "); 5809 annotate_signal_name (); 5810 if (ui_out_is_mi_like_p (uiout)) 5811 ui_out_field_string 5812 (uiout, "reason", async_reason_lookup (EXEC_ASYNC_SIGNAL_RECEIVED)); 5813 ui_out_field_string (uiout, "signal-name", 5814 target_signal_to_name (siggnal)); 5815 annotate_signal_name_end (); 5816 ui_out_text (uiout, ", "); 5817 annotate_signal_string (); 5818 ui_out_field_string (uiout, "signal-meaning", 5819 target_signal_to_string (siggnal)); 5820 annotate_signal_string_end (); 5821 } 5822 ui_out_text (uiout, ".\n"); 5823 } 5824 5825 /* Reverse execution: target ran out of history info, print why the inferior 5826 has stopped. */ 5827 5828 static void 5829 print_no_history_reason (void) 5830 { 5831 ui_out_text (current_uiout, "\nNo more reverse-execution history.\n"); 5832 } 5833 5834 /* Here to return control to GDB when the inferior stops for real. 5835 Print appropriate messages, remove breakpoints, give terminal our modes. 5836 5837 STOP_PRINT_FRAME nonzero means print the executing frame 5838 (pc, function, args, file, line number and line text). 5839 BREAKPOINTS_FAILED nonzero means stop was due to error 5840 attempting to insert breakpoints. */ 5841 5842 void 5843 normal_stop (void) 5844 { 5845 struct target_waitstatus last; 5846 ptid_t last_ptid; 5847 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL); 5848 5849 get_last_target_status (&last_ptid, &last); 5850 5851 /* If an exception is thrown from this point on, make sure to 5852 propagate GDB's knowledge of the executing state to the 5853 frontend/user running state. A QUIT is an easy exception to see 5854 here, so do this before any filtered output. */ 5855 if (!non_stop) 5856 make_cleanup (finish_thread_state_cleanup, &minus_one_ptid); 5857 else if (last.kind != TARGET_WAITKIND_SIGNALLED 5858 && last.kind != TARGET_WAITKIND_EXITED 5859 && last.kind != TARGET_WAITKIND_NO_RESUMED) 5860 make_cleanup (finish_thread_state_cleanup, &inferior_ptid); 5861 5862 /* In non-stop mode, we don't want GDB to switch threads behind the 5863 user's back, to avoid races where the user is typing a command to 5864 apply to thread x, but GDB switches to thread y before the user 5865 finishes entering the command. */ 5866 5867 /* As with the notification of thread events, we want to delay 5868 notifying the user that we've switched thread context until 5869 the inferior actually stops. 5870 5871 There's no point in saying anything if the inferior has exited. 5872 Note that SIGNALLED here means "exited with a signal", not 5873 "received a signal". */ 5874 if (!non_stop 5875 && !ptid_equal (previous_inferior_ptid, inferior_ptid) 5876 && target_has_execution 5877 && last.kind != TARGET_WAITKIND_SIGNALLED 5878 && last.kind != TARGET_WAITKIND_EXITED 5879 && last.kind != TARGET_WAITKIND_NO_RESUMED) 5880 { 5881 target_terminal_ours_for_output (); 5882 printf_filtered (_("[Switching to %s]\n"), 5883 target_pid_to_str (inferior_ptid)); 5884 annotate_thread_changed (); 5885 previous_inferior_ptid = inferior_ptid; 5886 } 5887 5888 if (last.kind == TARGET_WAITKIND_NO_RESUMED) 5889 { 5890 gdb_assert (sync_execution || !target_can_async_p ()); 5891 5892 target_terminal_ours_for_output (); 5893 printf_filtered (_("No unwaited-for children left.\n")); 5894 } 5895 5896 if (!breakpoints_always_inserted_mode () && target_has_execution) 5897 { 5898 if (remove_breakpoints ()) 5899 { 5900 target_terminal_ours_for_output (); 5901 printf_filtered (_("Cannot remove breakpoints because " 5902 "program is no longer writable.\nFurther " 5903 "execution is probably impossible.\n")); 5904 } 5905 } 5906 5907 /* If an auto-display called a function and that got a signal, 5908 delete that auto-display to avoid an infinite recursion. */ 5909 5910 if (stopped_by_random_signal) 5911 disable_current_display (); 5912 5913 /* Don't print a message if in the middle of doing a "step n" 5914 operation for n > 1 */ 5915 if (target_has_execution 5916 && last.kind != TARGET_WAITKIND_SIGNALLED 5917 && last.kind != TARGET_WAITKIND_EXITED 5918 && inferior_thread ()->step_multi 5919 && inferior_thread ()->control.stop_step) 5920 goto done; 5921 5922 target_terminal_ours (); 5923 async_enable_stdin (); 5924 5925 /* Set the current source location. This will also happen if we 5926 display the frame below, but the current SAL will be incorrect 5927 during a user hook-stop function. */ 5928 if (has_stack_frames () && !stop_stack_dummy) 5929 set_current_sal_from_frame (get_current_frame (), 1); 5930 5931 /* Let the user/frontend see the threads as stopped. */ 5932 do_cleanups (old_chain); 5933 5934 /* Look up the hook_stop and run it (CLI internally handles problem 5935 of stop_command's pre-hook not existing). */ 5936 if (stop_command) 5937 catch_errors (hook_stop_stub, stop_command, 5938 "Error while running hook_stop:\n", RETURN_MASK_ALL); 5939 5940 if (!has_stack_frames ()) 5941 goto done; 5942 5943 if (last.kind == TARGET_WAITKIND_SIGNALLED 5944 || last.kind == TARGET_WAITKIND_EXITED) 5945 goto done; 5946 5947 /* Select innermost stack frame - i.e., current frame is frame 0, 5948 and current location is based on that. 5949 Don't do this on return from a stack dummy routine, 5950 or if the program has exited. */ 5951 5952 if (!stop_stack_dummy) 5953 { 5954 select_frame (get_current_frame ()); 5955 5956 /* Print current location without a level number, if 5957 we have changed functions or hit a breakpoint. 5958 Print source line if we have one. 5959 bpstat_print() contains the logic deciding in detail 5960 what to print, based on the event(s) that just occurred. */ 5961 5962 /* If --batch-silent is enabled then there's no need to print the current 5963 source location, and to try risks causing an error message about 5964 missing source files. */ 5965 if (stop_print_frame && !batch_silent) 5966 { 5967 int bpstat_ret; 5968 int source_flag; 5969 int do_frame_printing = 1; 5970 struct thread_info *tp = inferior_thread (); 5971 5972 bpstat_ret = bpstat_print (tp->control.stop_bpstat, last.kind); 5973 switch (bpstat_ret) 5974 { 5975 case PRINT_UNKNOWN: 5976 /* FIXME: cagney/2002-12-01: Given that a frame ID does 5977 (or should) carry around the function and does (or 5978 should) use that when doing a frame comparison. */ 5979 if (tp->control.stop_step 5980 && frame_id_eq (tp->control.step_frame_id, 5981 get_frame_id (get_current_frame ())) 5982 && step_start_function == find_pc_function (stop_pc)) 5983 source_flag = SRC_LINE; /* Finished step, just 5984 print source line. */ 5985 else 5986 source_flag = SRC_AND_LOC; /* Print location and 5987 source line. */ 5988 break; 5989 case PRINT_SRC_AND_LOC: 5990 source_flag = SRC_AND_LOC; /* Print location and 5991 source line. */ 5992 break; 5993 case PRINT_SRC_ONLY: 5994 source_flag = SRC_LINE; 5995 break; 5996 case PRINT_NOTHING: 5997 source_flag = SRC_LINE; /* something bogus */ 5998 do_frame_printing = 0; 5999 break; 6000 default: 6001 internal_error (__FILE__, __LINE__, _("Unknown value.")); 6002 } 6003 6004 /* The behavior of this routine with respect to the source 6005 flag is: 6006 SRC_LINE: Print only source line 6007 LOCATION: Print only location 6008 SRC_AND_LOC: Print location and source line. */ 6009 if (do_frame_printing) 6010 print_stack_frame (get_selected_frame (NULL), 0, source_flag); 6011 6012 /* Display the auto-display expressions. */ 6013 do_displays (); 6014 } 6015 } 6016 6017 /* Save the function value return registers, if we care. 6018 We might be about to restore their previous contents. */ 6019 if (inferior_thread ()->control.proceed_to_finish 6020 && execution_direction != EXEC_REVERSE) 6021 { 6022 /* This should not be necessary. */ 6023 if (stop_registers) 6024 regcache_xfree (stop_registers); 6025 6026 /* NB: The copy goes through to the target picking up the value of 6027 all the registers. */ 6028 stop_registers = regcache_dup (get_current_regcache ()); 6029 } 6030 6031 if (stop_stack_dummy == STOP_STACK_DUMMY) 6032 { 6033 /* Pop the empty frame that contains the stack dummy. 6034 This also restores inferior state prior to the call 6035 (struct infcall_suspend_state). */ 6036 struct frame_info *frame = get_current_frame (); 6037 6038 gdb_assert (get_frame_type (frame) == DUMMY_FRAME); 6039 frame_pop (frame); 6040 /* frame_pop() calls reinit_frame_cache as the last thing it 6041 does which means there's currently no selected frame. We 6042 don't need to re-establish a selected frame if the dummy call 6043 returns normally, that will be done by 6044 restore_infcall_control_state. However, we do have to handle 6045 the case where the dummy call is returning after being 6046 stopped (e.g. the dummy call previously hit a breakpoint). 6047 We can't know which case we have so just always re-establish 6048 a selected frame here. */ 6049 select_frame (get_current_frame ()); 6050 } 6051 6052 done: 6053 annotate_stopped (); 6054 6055 /* Suppress the stop observer if we're in the middle of: 6056 6057 - a step n (n > 1), as there still more steps to be done. 6058 6059 - a "finish" command, as the observer will be called in 6060 finish_command_continuation, so it can include the inferior 6061 function's return value. 6062 6063 - calling an inferior function, as we pretend we inferior didn't 6064 run at all. The return value of the call is handled by the 6065 expression evaluator, through call_function_by_hand. */ 6066 6067 if (!target_has_execution 6068 || last.kind == TARGET_WAITKIND_SIGNALLED 6069 || last.kind == TARGET_WAITKIND_EXITED 6070 || last.kind == TARGET_WAITKIND_NO_RESUMED 6071 || (!inferior_thread ()->step_multi 6072 && !(inferior_thread ()->control.stop_bpstat 6073 && inferior_thread ()->control.proceed_to_finish) 6074 && !inferior_thread ()->control.in_infcall)) 6075 { 6076 if (!ptid_equal (inferior_ptid, null_ptid)) 6077 observer_notify_normal_stop (inferior_thread ()->control.stop_bpstat, 6078 stop_print_frame); 6079 else 6080 observer_notify_normal_stop (NULL, stop_print_frame); 6081 } 6082 6083 if (target_has_execution) 6084 { 6085 if (last.kind != TARGET_WAITKIND_SIGNALLED 6086 && last.kind != TARGET_WAITKIND_EXITED) 6087 /* Delete the breakpoint we stopped at, if it wants to be deleted. 6088 Delete any breakpoint that is to be deleted at the next stop. */ 6089 breakpoint_auto_delete (inferior_thread ()->control.stop_bpstat); 6090 } 6091 6092 /* Try to get rid of automatically added inferiors that are no 6093 longer needed. Keeping those around slows down things linearly. 6094 Note that this never removes the current inferior. */ 6095 prune_inferiors (); 6096 } 6097 6098 static int 6099 hook_stop_stub (void *cmd) 6100 { 6101 execute_cmd_pre_hook ((struct cmd_list_element *) cmd); 6102 return (0); 6103 } 6104 6105 int 6106 signal_stop_state (int signo) 6107 { 6108 return signal_stop[signo]; 6109 } 6110 6111 int 6112 signal_print_state (int signo) 6113 { 6114 return signal_print[signo]; 6115 } 6116 6117 int 6118 signal_pass_state (int signo) 6119 { 6120 return signal_program[signo]; 6121 } 6122 6123 static void 6124 signal_cache_update (int signo) 6125 { 6126 if (signo == -1) 6127 { 6128 for (signo = 0; signo < (int) TARGET_SIGNAL_LAST; signo++) 6129 signal_cache_update (signo); 6130 6131 return; 6132 } 6133 6134 signal_pass[signo] = (signal_stop[signo] == 0 6135 && signal_print[signo] == 0 6136 && signal_program[signo] == 1); 6137 } 6138 6139 int 6140 signal_stop_update (int signo, int state) 6141 { 6142 int ret = signal_stop[signo]; 6143 6144 signal_stop[signo] = state; 6145 signal_cache_update (signo); 6146 return ret; 6147 } 6148 6149 int 6150 signal_print_update (int signo, int state) 6151 { 6152 int ret = signal_print[signo]; 6153 6154 signal_print[signo] = state; 6155 signal_cache_update (signo); 6156 return ret; 6157 } 6158 6159 int 6160 signal_pass_update (int signo, int state) 6161 { 6162 int ret = signal_program[signo]; 6163 6164 signal_program[signo] = state; 6165 signal_cache_update (signo); 6166 return ret; 6167 } 6168 6169 static void 6170 sig_print_header (void) 6171 { 6172 printf_filtered (_("Signal Stop\tPrint\tPass " 6173 "to program\tDescription\n")); 6174 } 6175 6176 static void 6177 sig_print_info (enum target_signal oursig) 6178 { 6179 const char *name = target_signal_to_name (oursig); 6180 int name_padding = 13 - strlen (name); 6181 6182 if (name_padding <= 0) 6183 name_padding = 0; 6184 6185 printf_filtered ("%s", name); 6186 printf_filtered ("%*.*s ", name_padding, name_padding, " "); 6187 printf_filtered ("%s\t", signal_stop[oursig] ? "Yes" : "No"); 6188 printf_filtered ("%s\t", signal_print[oursig] ? "Yes" : "No"); 6189 printf_filtered ("%s\t\t", signal_program[oursig] ? "Yes" : "No"); 6190 printf_filtered ("%s\n", target_signal_to_string (oursig)); 6191 } 6192 6193 /* Specify how various signals in the inferior should be handled. */ 6194 6195 static void 6196 handle_command (char *args, int from_tty) 6197 { 6198 char **argv; 6199 int digits, wordlen; 6200 int sigfirst, signum, siglast; 6201 enum target_signal oursig; 6202 int allsigs; 6203 int nsigs; 6204 unsigned char *sigs; 6205 struct cleanup *old_chain; 6206 6207 if (args == NULL) 6208 { 6209 error_no_arg (_("signal to handle")); 6210 } 6211 6212 /* Allocate and zero an array of flags for which signals to handle. */ 6213 6214 nsigs = (int) TARGET_SIGNAL_LAST; 6215 sigs = (unsigned char *) alloca (nsigs); 6216 memset (sigs, 0, nsigs); 6217 6218 /* Break the command line up into args. */ 6219 6220 argv = gdb_buildargv (args); 6221 old_chain = make_cleanup_freeargv (argv); 6222 6223 /* Walk through the args, looking for signal oursigs, signal names, and 6224 actions. Signal numbers and signal names may be interspersed with 6225 actions, with the actions being performed for all signals cumulatively 6226 specified. Signal ranges can be specified as <LOW>-<HIGH>. */ 6227 6228 while (*argv != NULL) 6229 { 6230 wordlen = strlen (*argv); 6231 for (digits = 0; isdigit ((*argv)[digits]); digits++) 6232 {; 6233 } 6234 allsigs = 0; 6235 sigfirst = siglast = -1; 6236 6237 if (wordlen >= 1 && !strncmp (*argv, "all", wordlen)) 6238 { 6239 /* Apply action to all signals except those used by the 6240 debugger. Silently skip those. */ 6241 allsigs = 1; 6242 sigfirst = 0; 6243 siglast = nsigs - 1; 6244 } 6245 else if (wordlen >= 1 && !strncmp (*argv, "stop", wordlen)) 6246 { 6247 SET_SIGS (nsigs, sigs, signal_stop); 6248 SET_SIGS (nsigs, sigs, signal_print); 6249 } 6250 else if (wordlen >= 1 && !strncmp (*argv, "ignore", wordlen)) 6251 { 6252 UNSET_SIGS (nsigs, sigs, signal_program); 6253 } 6254 else if (wordlen >= 2 && !strncmp (*argv, "print", wordlen)) 6255 { 6256 SET_SIGS (nsigs, sigs, signal_print); 6257 } 6258 else if (wordlen >= 2 && !strncmp (*argv, "pass", wordlen)) 6259 { 6260 SET_SIGS (nsigs, sigs, signal_program); 6261 } 6262 else if (wordlen >= 3 && !strncmp (*argv, "nostop", wordlen)) 6263 { 6264 UNSET_SIGS (nsigs, sigs, signal_stop); 6265 } 6266 else if (wordlen >= 3 && !strncmp (*argv, "noignore", wordlen)) 6267 { 6268 SET_SIGS (nsigs, sigs, signal_program); 6269 } 6270 else if (wordlen >= 4 && !strncmp (*argv, "noprint", wordlen)) 6271 { 6272 UNSET_SIGS (nsigs, sigs, signal_print); 6273 UNSET_SIGS (nsigs, sigs, signal_stop); 6274 } 6275 else if (wordlen >= 4 && !strncmp (*argv, "nopass", wordlen)) 6276 { 6277 UNSET_SIGS (nsigs, sigs, signal_program); 6278 } 6279 else if (digits > 0) 6280 { 6281 /* It is numeric. The numeric signal refers to our own 6282 internal signal numbering from target.h, not to host/target 6283 signal number. This is a feature; users really should be 6284 using symbolic names anyway, and the common ones like 6285 SIGHUP, SIGINT, SIGALRM, etc. will work right anyway. */ 6286 6287 sigfirst = siglast = (int) 6288 target_signal_from_command (atoi (*argv)); 6289 if ((*argv)[digits] == '-') 6290 { 6291 siglast = (int) 6292 target_signal_from_command (atoi ((*argv) + digits + 1)); 6293 } 6294 if (sigfirst > siglast) 6295 { 6296 /* Bet he didn't figure we'd think of this case... */ 6297 signum = sigfirst; 6298 sigfirst = siglast; 6299 siglast = signum; 6300 } 6301 } 6302 else 6303 { 6304 oursig = target_signal_from_name (*argv); 6305 if (oursig != TARGET_SIGNAL_UNKNOWN) 6306 { 6307 sigfirst = siglast = (int) oursig; 6308 } 6309 else 6310 { 6311 /* Not a number and not a recognized flag word => complain. */ 6312 error (_("Unrecognized or ambiguous flag word: \"%s\"."), *argv); 6313 } 6314 } 6315 6316 /* If any signal numbers or symbol names were found, set flags for 6317 which signals to apply actions to. */ 6318 6319 for (signum = sigfirst; signum >= 0 && signum <= siglast; signum++) 6320 { 6321 switch ((enum target_signal) signum) 6322 { 6323 case TARGET_SIGNAL_TRAP: 6324 case TARGET_SIGNAL_INT: 6325 if (!allsigs && !sigs[signum]) 6326 { 6327 if (query (_("%s is used by the debugger.\n\ 6328 Are you sure you want to change it? "), 6329 target_signal_to_name ((enum target_signal) signum))) 6330 { 6331 sigs[signum] = 1; 6332 } 6333 else 6334 { 6335 printf_unfiltered (_("Not confirmed, unchanged.\n")); 6336 gdb_flush (gdb_stdout); 6337 } 6338 } 6339 break; 6340 case TARGET_SIGNAL_0: 6341 case TARGET_SIGNAL_DEFAULT: 6342 case TARGET_SIGNAL_UNKNOWN: 6343 /* Make sure that "all" doesn't print these. */ 6344 break; 6345 default: 6346 sigs[signum] = 1; 6347 break; 6348 } 6349 } 6350 6351 argv++; 6352 } 6353 6354 for (signum = 0; signum < nsigs; signum++) 6355 if (sigs[signum]) 6356 { 6357 signal_cache_update (-1); 6358 target_pass_signals ((int) TARGET_SIGNAL_LAST, signal_pass); 6359 6360 if (from_tty) 6361 { 6362 /* Show the results. */ 6363 sig_print_header (); 6364 for (; signum < nsigs; signum++) 6365 if (sigs[signum]) 6366 sig_print_info (signum); 6367 } 6368 6369 break; 6370 } 6371 6372 do_cleanups (old_chain); 6373 } 6374 6375 static void 6376 xdb_handle_command (char *args, int from_tty) 6377 { 6378 char **argv; 6379 struct cleanup *old_chain; 6380 6381 if (args == NULL) 6382 error_no_arg (_("xdb command")); 6383 6384 /* Break the command line up into args. */ 6385 6386 argv = gdb_buildargv (args); 6387 old_chain = make_cleanup_freeargv (argv); 6388 if (argv[1] != (char *) NULL) 6389 { 6390 char *argBuf; 6391 int bufLen; 6392 6393 bufLen = strlen (argv[0]) + 20; 6394 argBuf = (char *) xmalloc (bufLen); 6395 if (argBuf) 6396 { 6397 int validFlag = 1; 6398 enum target_signal oursig; 6399 6400 oursig = target_signal_from_name (argv[0]); 6401 memset (argBuf, 0, bufLen); 6402 if (strcmp (argv[1], "Q") == 0) 6403 sprintf (argBuf, "%s %s", argv[0], "noprint"); 6404 else 6405 { 6406 if (strcmp (argv[1], "s") == 0) 6407 { 6408 if (!signal_stop[oursig]) 6409 sprintf (argBuf, "%s %s", argv[0], "stop"); 6410 else 6411 sprintf (argBuf, "%s %s", argv[0], "nostop"); 6412 } 6413 else if (strcmp (argv[1], "i") == 0) 6414 { 6415 if (!signal_program[oursig]) 6416 sprintf (argBuf, "%s %s", argv[0], "pass"); 6417 else 6418 sprintf (argBuf, "%s %s", argv[0], "nopass"); 6419 } 6420 else if (strcmp (argv[1], "r") == 0) 6421 { 6422 if (!signal_print[oursig]) 6423 sprintf (argBuf, "%s %s", argv[0], "print"); 6424 else 6425 sprintf (argBuf, "%s %s", argv[0], "noprint"); 6426 } 6427 else 6428 validFlag = 0; 6429 } 6430 if (validFlag) 6431 handle_command (argBuf, from_tty); 6432 else 6433 printf_filtered (_("Invalid signal handling flag.\n")); 6434 if (argBuf) 6435 xfree (argBuf); 6436 } 6437 } 6438 do_cleanups (old_chain); 6439 } 6440 6441 /* Print current contents of the tables set by the handle command. 6442 It is possible we should just be printing signals actually used 6443 by the current target (but for things to work right when switching 6444 targets, all signals should be in the signal tables). */ 6445 6446 static void 6447 signals_info (char *signum_exp, int from_tty) 6448 { 6449 enum target_signal oursig; 6450 6451 sig_print_header (); 6452 6453 if (signum_exp) 6454 { 6455 /* First see if this is a symbol name. */ 6456 oursig = target_signal_from_name (signum_exp); 6457 if (oursig == TARGET_SIGNAL_UNKNOWN) 6458 { 6459 /* No, try numeric. */ 6460 oursig = 6461 target_signal_from_command (parse_and_eval_long (signum_exp)); 6462 } 6463 sig_print_info (oursig); 6464 return; 6465 } 6466 6467 printf_filtered ("\n"); 6468 /* These ugly casts brought to you by the native VAX compiler. */ 6469 for (oursig = TARGET_SIGNAL_FIRST; 6470 (int) oursig < (int) TARGET_SIGNAL_LAST; 6471 oursig = (enum target_signal) ((int) oursig + 1)) 6472 { 6473 QUIT; 6474 6475 if (oursig != TARGET_SIGNAL_UNKNOWN 6476 && oursig != TARGET_SIGNAL_DEFAULT && oursig != TARGET_SIGNAL_0) 6477 sig_print_info (oursig); 6478 } 6479 6480 printf_filtered (_("\nUse the \"handle\" command " 6481 "to change these tables.\n")); 6482 } 6483 6484 /* Check if it makes sense to read $_siginfo from the current thread 6485 at this point. If not, throw an error. */ 6486 6487 static void 6488 validate_siginfo_access (void) 6489 { 6490 /* No current inferior, no siginfo. */ 6491 if (ptid_equal (inferior_ptid, null_ptid)) 6492 error (_("No thread selected.")); 6493 6494 /* Don't try to read from a dead thread. */ 6495 if (is_exited (inferior_ptid)) 6496 error (_("The current thread has terminated")); 6497 6498 /* ... or from a spinning thread. */ 6499 if (is_running (inferior_ptid)) 6500 error (_("Selected thread is running.")); 6501 } 6502 6503 /* The $_siginfo convenience variable is a bit special. We don't know 6504 for sure the type of the value until we actually have a chance to 6505 fetch the data. The type can change depending on gdbarch, so it is 6506 also dependent on which thread you have selected. 6507 6508 1. making $_siginfo be an internalvar that creates a new value on 6509 access. 6510 6511 2. making the value of $_siginfo be an lval_computed value. */ 6512 6513 /* This function implements the lval_computed support for reading a 6514 $_siginfo value. */ 6515 6516 static void 6517 siginfo_value_read (struct value *v) 6518 { 6519 LONGEST transferred; 6520 6521 validate_siginfo_access (); 6522 6523 transferred = 6524 target_read (¤t_target, TARGET_OBJECT_SIGNAL_INFO, 6525 NULL, 6526 value_contents_all_raw (v), 6527 value_offset (v), 6528 TYPE_LENGTH (value_type (v))); 6529 6530 if (transferred != TYPE_LENGTH (value_type (v))) 6531 error (_("Unable to read siginfo")); 6532 } 6533 6534 /* This function implements the lval_computed support for writing a 6535 $_siginfo value. */ 6536 6537 static void 6538 siginfo_value_write (struct value *v, struct value *fromval) 6539 { 6540 LONGEST transferred; 6541 6542 validate_siginfo_access (); 6543 6544 transferred = target_write (¤t_target, 6545 TARGET_OBJECT_SIGNAL_INFO, 6546 NULL, 6547 value_contents_all_raw (fromval), 6548 value_offset (v), 6549 TYPE_LENGTH (value_type (fromval))); 6550 6551 if (transferred != TYPE_LENGTH (value_type (fromval))) 6552 error (_("Unable to write siginfo")); 6553 } 6554 6555 static const struct lval_funcs siginfo_value_funcs = 6556 { 6557 siginfo_value_read, 6558 siginfo_value_write 6559 }; 6560 6561 /* Return a new value with the correct type for the siginfo object of 6562 the current thread using architecture GDBARCH. Return a void value 6563 if there's no object available. */ 6564 6565 static struct value * 6566 siginfo_make_value (struct gdbarch *gdbarch, struct internalvar *var) 6567 { 6568 if (target_has_stack 6569 && !ptid_equal (inferior_ptid, null_ptid) 6570 && gdbarch_get_siginfo_type_p (gdbarch)) 6571 { 6572 struct type *type = gdbarch_get_siginfo_type (gdbarch); 6573 6574 return allocate_computed_value (type, &siginfo_value_funcs, NULL); 6575 } 6576 6577 return allocate_value (builtin_type (gdbarch)->builtin_void); 6578 } 6579 6580 6581 /* infcall_suspend_state contains state about the program itself like its 6582 registers and any signal it received when it last stopped. 6583 This state must be restored regardless of how the inferior function call 6584 ends (either successfully, or after it hits a breakpoint or signal) 6585 if the program is to properly continue where it left off. */ 6586 6587 struct infcall_suspend_state 6588 { 6589 struct thread_suspend_state thread_suspend; 6590 struct inferior_suspend_state inferior_suspend; 6591 6592 /* Other fields: */ 6593 CORE_ADDR stop_pc; 6594 struct regcache *registers; 6595 6596 /* Format of SIGINFO_DATA or NULL if it is not present. */ 6597 struct gdbarch *siginfo_gdbarch; 6598 6599 /* The inferior format depends on SIGINFO_GDBARCH and it has a length of 6600 TYPE_LENGTH (gdbarch_get_siginfo_type ()). For different gdbarch the 6601 content would be invalid. */ 6602 gdb_byte *siginfo_data; 6603 }; 6604 6605 struct infcall_suspend_state * 6606 save_infcall_suspend_state (void) 6607 { 6608 struct infcall_suspend_state *inf_state; 6609 struct thread_info *tp = inferior_thread (); 6610 struct inferior *inf = current_inferior (); 6611 struct regcache *regcache = get_current_regcache (); 6612 struct gdbarch *gdbarch = get_regcache_arch (regcache); 6613 gdb_byte *siginfo_data = NULL; 6614 6615 if (gdbarch_get_siginfo_type_p (gdbarch)) 6616 { 6617 struct type *type = gdbarch_get_siginfo_type (gdbarch); 6618 size_t len = TYPE_LENGTH (type); 6619 struct cleanup *back_to; 6620 6621 siginfo_data = xmalloc (len); 6622 back_to = make_cleanup (xfree, siginfo_data); 6623 6624 if (target_read (¤t_target, TARGET_OBJECT_SIGNAL_INFO, NULL, 6625 siginfo_data, 0, len) == len) 6626 discard_cleanups (back_to); 6627 else 6628 { 6629 /* Errors ignored. */ 6630 do_cleanups (back_to); 6631 siginfo_data = NULL; 6632 } 6633 } 6634 6635 inf_state = XZALLOC (struct infcall_suspend_state); 6636 6637 if (siginfo_data) 6638 { 6639 inf_state->siginfo_gdbarch = gdbarch; 6640 inf_state->siginfo_data = siginfo_data; 6641 } 6642 6643 inf_state->thread_suspend = tp->suspend; 6644 inf_state->inferior_suspend = inf->suspend; 6645 6646 /* run_inferior_call will not use the signal due to its `proceed' call with 6647 TARGET_SIGNAL_0 anyway. */ 6648 tp->suspend.stop_signal = TARGET_SIGNAL_0; 6649 6650 inf_state->stop_pc = stop_pc; 6651 6652 inf_state->registers = regcache_dup (regcache); 6653 6654 return inf_state; 6655 } 6656 6657 /* Restore inferior session state to INF_STATE. */ 6658 6659 void 6660 restore_infcall_suspend_state (struct infcall_suspend_state *inf_state) 6661 { 6662 struct thread_info *tp = inferior_thread (); 6663 struct inferior *inf = current_inferior (); 6664 struct regcache *regcache = get_current_regcache (); 6665 struct gdbarch *gdbarch = get_regcache_arch (regcache); 6666 6667 tp->suspend = inf_state->thread_suspend; 6668 inf->suspend = inf_state->inferior_suspend; 6669 6670 stop_pc = inf_state->stop_pc; 6671 6672 if (inf_state->siginfo_gdbarch == gdbarch) 6673 { 6674 struct type *type = gdbarch_get_siginfo_type (gdbarch); 6675 size_t len = TYPE_LENGTH (type); 6676 6677 /* Errors ignored. */ 6678 target_write (¤t_target, TARGET_OBJECT_SIGNAL_INFO, NULL, 6679 inf_state->siginfo_data, 0, len); 6680 } 6681 6682 /* The inferior can be gone if the user types "print exit(0)" 6683 (and perhaps other times). */ 6684 if (target_has_execution) 6685 /* NB: The register write goes through to the target. */ 6686 regcache_cpy (regcache, inf_state->registers); 6687 6688 discard_infcall_suspend_state (inf_state); 6689 } 6690 6691 static void 6692 do_restore_infcall_suspend_state_cleanup (void *state) 6693 { 6694 restore_infcall_suspend_state (state); 6695 } 6696 6697 struct cleanup * 6698 make_cleanup_restore_infcall_suspend_state 6699 (struct infcall_suspend_state *inf_state) 6700 { 6701 return make_cleanup (do_restore_infcall_suspend_state_cleanup, inf_state); 6702 } 6703 6704 void 6705 discard_infcall_suspend_state (struct infcall_suspend_state *inf_state) 6706 { 6707 regcache_xfree (inf_state->registers); 6708 xfree (inf_state->siginfo_data); 6709 xfree (inf_state); 6710 } 6711 6712 struct regcache * 6713 get_infcall_suspend_state_regcache (struct infcall_suspend_state *inf_state) 6714 { 6715 return inf_state->registers; 6716 } 6717 6718 /* infcall_control_state contains state regarding gdb's control of the 6719 inferior itself like stepping control. It also contains session state like 6720 the user's currently selected frame. */ 6721 6722 struct infcall_control_state 6723 { 6724 struct thread_control_state thread_control; 6725 struct inferior_control_state inferior_control; 6726 6727 /* Other fields: */ 6728 enum stop_stack_kind stop_stack_dummy; 6729 int stopped_by_random_signal; 6730 int stop_after_trap; 6731 6732 /* ID if the selected frame when the inferior function call was made. */ 6733 struct frame_id selected_frame_id; 6734 }; 6735 6736 /* Save all of the information associated with the inferior<==>gdb 6737 connection. */ 6738 6739 struct infcall_control_state * 6740 save_infcall_control_state (void) 6741 { 6742 struct infcall_control_state *inf_status = xmalloc (sizeof (*inf_status)); 6743 struct thread_info *tp = inferior_thread (); 6744 struct inferior *inf = current_inferior (); 6745 6746 inf_status->thread_control = tp->control; 6747 inf_status->inferior_control = inf->control; 6748 6749 tp->control.step_resume_breakpoint = NULL; 6750 tp->control.exception_resume_breakpoint = NULL; 6751 6752 /* Save original bpstat chain to INF_STATUS; replace it in TP with copy of 6753 chain. If caller's caller is walking the chain, they'll be happier if we 6754 hand them back the original chain when restore_infcall_control_state is 6755 called. */ 6756 tp->control.stop_bpstat = bpstat_copy (tp->control.stop_bpstat); 6757 6758 /* Other fields: */ 6759 inf_status->stop_stack_dummy = stop_stack_dummy; 6760 inf_status->stopped_by_random_signal = stopped_by_random_signal; 6761 inf_status->stop_after_trap = stop_after_trap; 6762 6763 inf_status->selected_frame_id = get_frame_id (get_selected_frame (NULL)); 6764 6765 return inf_status; 6766 } 6767 6768 static int 6769 restore_selected_frame (void *args) 6770 { 6771 struct frame_id *fid = (struct frame_id *) args; 6772 struct frame_info *frame; 6773 6774 frame = frame_find_by_id (*fid); 6775 6776 /* If inf_status->selected_frame_id is NULL, there was no previously 6777 selected frame. */ 6778 if (frame == NULL) 6779 { 6780 warning (_("Unable to restore previously selected frame.")); 6781 return 0; 6782 } 6783 6784 select_frame (frame); 6785 6786 return (1); 6787 } 6788 6789 /* Restore inferior session state to INF_STATUS. */ 6790 6791 void 6792 restore_infcall_control_state (struct infcall_control_state *inf_status) 6793 { 6794 struct thread_info *tp = inferior_thread (); 6795 struct inferior *inf = current_inferior (); 6796 6797 if (tp->control.step_resume_breakpoint) 6798 tp->control.step_resume_breakpoint->disposition = disp_del_at_next_stop; 6799 6800 if (tp->control.exception_resume_breakpoint) 6801 tp->control.exception_resume_breakpoint->disposition 6802 = disp_del_at_next_stop; 6803 6804 /* Handle the bpstat_copy of the chain. */ 6805 bpstat_clear (&tp->control.stop_bpstat); 6806 6807 tp->control = inf_status->thread_control; 6808 inf->control = inf_status->inferior_control; 6809 6810 /* Other fields: */ 6811 stop_stack_dummy = inf_status->stop_stack_dummy; 6812 stopped_by_random_signal = inf_status->stopped_by_random_signal; 6813 stop_after_trap = inf_status->stop_after_trap; 6814 6815 if (target_has_stack) 6816 { 6817 /* The point of catch_errors is that if the stack is clobbered, 6818 walking the stack might encounter a garbage pointer and 6819 error() trying to dereference it. */ 6820 if (catch_errors 6821 (restore_selected_frame, &inf_status->selected_frame_id, 6822 "Unable to restore previously selected frame:\n", 6823 RETURN_MASK_ERROR) == 0) 6824 /* Error in restoring the selected frame. Select the innermost 6825 frame. */ 6826 select_frame (get_current_frame ()); 6827 } 6828 6829 xfree (inf_status); 6830 } 6831 6832 static void 6833 do_restore_infcall_control_state_cleanup (void *sts) 6834 { 6835 restore_infcall_control_state (sts); 6836 } 6837 6838 struct cleanup * 6839 make_cleanup_restore_infcall_control_state 6840 (struct infcall_control_state *inf_status) 6841 { 6842 return make_cleanup (do_restore_infcall_control_state_cleanup, inf_status); 6843 } 6844 6845 void 6846 discard_infcall_control_state (struct infcall_control_state *inf_status) 6847 { 6848 if (inf_status->thread_control.step_resume_breakpoint) 6849 inf_status->thread_control.step_resume_breakpoint->disposition 6850 = disp_del_at_next_stop; 6851 6852 if (inf_status->thread_control.exception_resume_breakpoint) 6853 inf_status->thread_control.exception_resume_breakpoint->disposition 6854 = disp_del_at_next_stop; 6855 6856 /* See save_infcall_control_state for info on stop_bpstat. */ 6857 bpstat_clear (&inf_status->thread_control.stop_bpstat); 6858 6859 xfree (inf_status); 6860 } 6861 6862 int 6863 inferior_has_forked (ptid_t pid, ptid_t *child_pid) 6864 { 6865 struct target_waitstatus last; 6866 ptid_t last_ptid; 6867 6868 get_last_target_status (&last_ptid, &last); 6869 6870 if (last.kind != TARGET_WAITKIND_FORKED) 6871 return 0; 6872 6873 if (!ptid_equal (last_ptid, pid)) 6874 return 0; 6875 6876 *child_pid = last.value.related_pid; 6877 return 1; 6878 } 6879 6880 int 6881 inferior_has_vforked (ptid_t pid, ptid_t *child_pid) 6882 { 6883 struct target_waitstatus last; 6884 ptid_t last_ptid; 6885 6886 get_last_target_status (&last_ptid, &last); 6887 6888 if (last.kind != TARGET_WAITKIND_VFORKED) 6889 return 0; 6890 6891 if (!ptid_equal (last_ptid, pid)) 6892 return 0; 6893 6894 *child_pid = last.value.related_pid; 6895 return 1; 6896 } 6897 6898 int 6899 inferior_has_execd (ptid_t pid, char **execd_pathname) 6900 { 6901 struct target_waitstatus last; 6902 ptid_t last_ptid; 6903 6904 get_last_target_status (&last_ptid, &last); 6905 6906 if (last.kind != TARGET_WAITKIND_EXECD) 6907 return 0; 6908 6909 if (!ptid_equal (last_ptid, pid)) 6910 return 0; 6911 6912 *execd_pathname = xstrdup (last.value.execd_pathname); 6913 return 1; 6914 } 6915 6916 int 6917 inferior_has_called_syscall (ptid_t pid, int *syscall_number) 6918 { 6919 struct target_waitstatus last; 6920 ptid_t last_ptid; 6921 6922 get_last_target_status (&last_ptid, &last); 6923 6924 if (last.kind != TARGET_WAITKIND_SYSCALL_ENTRY && 6925 last.kind != TARGET_WAITKIND_SYSCALL_RETURN) 6926 return 0; 6927 6928 if (!ptid_equal (last_ptid, pid)) 6929 return 0; 6930 6931 *syscall_number = last.value.syscall_number; 6932 return 1; 6933 } 6934 6935 int 6936 ptid_match (ptid_t ptid, ptid_t filter) 6937 { 6938 if (ptid_equal (filter, minus_one_ptid)) 6939 return 1; 6940 if (ptid_is_pid (filter) 6941 && ptid_get_pid (ptid) == ptid_get_pid (filter)) 6942 return 1; 6943 else if (ptid_equal (ptid, filter)) 6944 return 1; 6945 6946 return 0; 6947 } 6948 6949 /* restore_inferior_ptid() will be used by the cleanup machinery 6950 to restore the inferior_ptid value saved in a call to 6951 save_inferior_ptid(). */ 6952 6953 static void 6954 restore_inferior_ptid (void *arg) 6955 { 6956 ptid_t *saved_ptid_ptr = arg; 6957 6958 inferior_ptid = *saved_ptid_ptr; 6959 xfree (arg); 6960 } 6961 6962 /* Save the value of inferior_ptid so that it may be restored by a 6963 later call to do_cleanups(). Returns the struct cleanup pointer 6964 needed for later doing the cleanup. */ 6965 6966 struct cleanup * 6967 save_inferior_ptid (void) 6968 { 6969 ptid_t *saved_ptid_ptr; 6970 6971 saved_ptid_ptr = xmalloc (sizeof (ptid_t)); 6972 *saved_ptid_ptr = inferior_ptid; 6973 return make_cleanup (restore_inferior_ptid, saved_ptid_ptr); 6974 } 6975 6976 6977 /* User interface for reverse debugging: 6978 Set exec-direction / show exec-direction commands 6979 (returns error unless target implements to_set_exec_direction method). */ 6980 6981 int execution_direction = EXEC_FORWARD; 6982 static const char exec_forward[] = "forward"; 6983 static const char exec_reverse[] = "reverse"; 6984 static const char *exec_direction = exec_forward; 6985 static const char *exec_direction_names[] = { 6986 exec_forward, 6987 exec_reverse, 6988 NULL 6989 }; 6990 6991 static void 6992 set_exec_direction_func (char *args, int from_tty, 6993 struct cmd_list_element *cmd) 6994 { 6995 if (target_can_execute_reverse) 6996 { 6997 if (!strcmp (exec_direction, exec_forward)) 6998 execution_direction = EXEC_FORWARD; 6999 else if (!strcmp (exec_direction, exec_reverse)) 7000 execution_direction = EXEC_REVERSE; 7001 } 7002 else 7003 { 7004 exec_direction = exec_forward; 7005 error (_("Target does not support this operation.")); 7006 } 7007 } 7008 7009 static void 7010 show_exec_direction_func (struct ui_file *out, int from_tty, 7011 struct cmd_list_element *cmd, const char *value) 7012 { 7013 switch (execution_direction) { 7014 case EXEC_FORWARD: 7015 fprintf_filtered (out, _("Forward.\n")); 7016 break; 7017 case EXEC_REVERSE: 7018 fprintf_filtered (out, _("Reverse.\n")); 7019 break; 7020 default: 7021 internal_error (__FILE__, __LINE__, 7022 _("bogus execution_direction value: %d"), 7023 (int) execution_direction); 7024 } 7025 } 7026 7027 /* User interface for non-stop mode. */ 7028 7029 int non_stop = 0; 7030 7031 static void 7032 set_non_stop (char *args, int from_tty, 7033 struct cmd_list_element *c) 7034 { 7035 if (target_has_execution) 7036 { 7037 non_stop_1 = non_stop; 7038 error (_("Cannot change this setting while the inferior is running.")); 7039 } 7040 7041 non_stop = non_stop_1; 7042 } 7043 7044 static void 7045 show_non_stop (struct ui_file *file, int from_tty, 7046 struct cmd_list_element *c, const char *value) 7047 { 7048 fprintf_filtered (file, 7049 _("Controlling the inferior in non-stop mode is %s.\n"), 7050 value); 7051 } 7052 7053 static void 7054 show_schedule_multiple (struct ui_file *file, int from_tty, 7055 struct cmd_list_element *c, const char *value) 7056 { 7057 fprintf_filtered (file, _("Resuming the execution of threads " 7058 "of all processes is %s.\n"), value); 7059 } 7060 7061 void 7062 _initialize_infrun (void) 7063 { 7064 int i; 7065 int numsigs; 7066 7067 add_info ("signals", signals_info, _("\ 7068 What debugger does when program gets various signals.\n\ 7069 Specify a signal as argument to print info on that signal only.")); 7070 add_info_alias ("handle", "signals", 0); 7071 7072 add_com ("handle", class_run, handle_command, _("\ 7073 Specify how to handle a signal.\n\ 7074 Args are signals and actions to apply to those signals.\n\ 7075 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\ 7076 from 1-15 are allowed for compatibility with old versions of GDB.\n\ 7077 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\ 7078 The special arg \"all\" is recognized to mean all signals except those\n\ 7079 used by the debugger, typically SIGTRAP and SIGINT.\n\ 7080 Recognized actions include \"stop\", \"nostop\", \"print\", \"noprint\",\n\ 7081 \"pass\", \"nopass\", \"ignore\", or \"noignore\".\n\ 7082 Stop means reenter debugger if this signal happens (implies print).\n\ 7083 Print means print a message if this signal happens.\n\ 7084 Pass means let program see this signal; otherwise program doesn't know.\n\ 7085 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\ 7086 Pass and Stop may be combined.")); 7087 if (xdb_commands) 7088 { 7089 add_com ("lz", class_info, signals_info, _("\ 7090 What debugger does when program gets various signals.\n\ 7091 Specify a signal as argument to print info on that signal only.")); 7092 add_com ("z", class_run, xdb_handle_command, _("\ 7093 Specify how to handle a signal.\n\ 7094 Args are signals and actions to apply to those signals.\n\ 7095 Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\ 7096 from 1-15 are allowed for compatibility with old versions of GDB.\n\ 7097 Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\ 7098 The special arg \"all\" is recognized to mean all signals except those\n\ 7099 used by the debugger, typically SIGTRAP and SIGINT.\n\ 7100 Recognized actions include \"s\" (toggles between stop and nostop),\n\ 7101 \"r\" (toggles between print and noprint), \"i\" (toggles between pass and \ 7102 nopass), \"Q\" (noprint)\n\ 7103 Stop means reenter debugger if this signal happens (implies print).\n\ 7104 Print means print a message if this signal happens.\n\ 7105 Pass means let program see this signal; otherwise program doesn't know.\n\ 7106 Ignore is a synonym for nopass and noignore is a synonym for pass.\n\ 7107 Pass and Stop may be combined.")); 7108 } 7109 7110 if (!dbx_commands) 7111 stop_command = add_cmd ("stop", class_obscure, 7112 not_just_help_class_command, _("\ 7113 There is no `stop' command, but you can set a hook on `stop'.\n\ 7114 This allows you to set a list of commands to be run each time execution\n\ 7115 of the program stops."), &cmdlist); 7116 7117 add_setshow_zinteger_cmd ("infrun", class_maintenance, &debug_infrun, _("\ 7118 Set inferior debugging."), _("\ 7119 Show inferior debugging."), _("\ 7120 When non-zero, inferior specific debugging is enabled."), 7121 NULL, 7122 show_debug_infrun, 7123 &setdebuglist, &showdebuglist); 7124 7125 add_setshow_boolean_cmd ("displaced", class_maintenance, 7126 &debug_displaced, _("\ 7127 Set displaced stepping debugging."), _("\ 7128 Show displaced stepping debugging."), _("\ 7129 When non-zero, displaced stepping specific debugging is enabled."), 7130 NULL, 7131 show_debug_displaced, 7132 &setdebuglist, &showdebuglist); 7133 7134 add_setshow_boolean_cmd ("non-stop", no_class, 7135 &non_stop_1, _("\ 7136 Set whether gdb controls the inferior in non-stop mode."), _("\ 7137 Show whether gdb controls the inferior in non-stop mode."), _("\ 7138 When debugging a multi-threaded program and this setting is\n\ 7139 off (the default, also called all-stop mode), when one thread stops\n\ 7140 (for a breakpoint, watchpoint, exception, or similar events), GDB stops\n\ 7141 all other threads in the program while you interact with the thread of\n\ 7142 interest. When you continue or step a thread, you can allow the other\n\ 7143 threads to run, or have them remain stopped, but while you inspect any\n\ 7144 thread's state, all threads stop.\n\ 7145 \n\ 7146 In non-stop mode, when one thread stops, other threads can continue\n\ 7147 to run freely. You'll be able to step each thread independently,\n\ 7148 leave it stopped or free to run as needed."), 7149 set_non_stop, 7150 show_non_stop, 7151 &setlist, 7152 &showlist); 7153 7154 numsigs = (int) TARGET_SIGNAL_LAST; 7155 signal_stop = (unsigned char *) xmalloc (sizeof (signal_stop[0]) * numsigs); 7156 signal_print = (unsigned char *) 7157 xmalloc (sizeof (signal_print[0]) * numsigs); 7158 signal_program = (unsigned char *) 7159 xmalloc (sizeof (signal_program[0]) * numsigs); 7160 signal_pass = (unsigned char *) 7161 xmalloc (sizeof (signal_program[0]) * numsigs); 7162 for (i = 0; i < numsigs; i++) 7163 { 7164 signal_stop[i] = 1; 7165 signal_print[i] = 1; 7166 signal_program[i] = 1; 7167 } 7168 7169 /* Signals caused by debugger's own actions 7170 should not be given to the program afterwards. */ 7171 signal_program[TARGET_SIGNAL_TRAP] = 0; 7172 signal_program[TARGET_SIGNAL_INT] = 0; 7173 7174 /* Signals that are not errors should not normally enter the debugger. */ 7175 signal_stop[TARGET_SIGNAL_ALRM] = 0; 7176 signal_print[TARGET_SIGNAL_ALRM] = 0; 7177 signal_stop[TARGET_SIGNAL_VTALRM] = 0; 7178 signal_print[TARGET_SIGNAL_VTALRM] = 0; 7179 signal_stop[TARGET_SIGNAL_PROF] = 0; 7180 signal_print[TARGET_SIGNAL_PROF] = 0; 7181 signal_stop[TARGET_SIGNAL_CHLD] = 0; 7182 signal_print[TARGET_SIGNAL_CHLD] = 0; 7183 signal_stop[TARGET_SIGNAL_IO] = 0; 7184 signal_print[TARGET_SIGNAL_IO] = 0; 7185 signal_stop[TARGET_SIGNAL_POLL] = 0; 7186 signal_print[TARGET_SIGNAL_POLL] = 0; 7187 signal_stop[TARGET_SIGNAL_URG] = 0; 7188 signal_print[TARGET_SIGNAL_URG] = 0; 7189 signal_stop[TARGET_SIGNAL_WINCH] = 0; 7190 signal_print[TARGET_SIGNAL_WINCH] = 0; 7191 signal_stop[TARGET_SIGNAL_PRIO] = 0; 7192 signal_print[TARGET_SIGNAL_PRIO] = 0; 7193 7194 /* These signals are used internally by user-level thread 7195 implementations. (See signal(5) on Solaris.) Like the above 7196 signals, a healthy program receives and handles them as part of 7197 its normal operation. */ 7198 signal_stop[TARGET_SIGNAL_LWP] = 0; 7199 signal_print[TARGET_SIGNAL_LWP] = 0; 7200 signal_stop[TARGET_SIGNAL_WAITING] = 0; 7201 signal_print[TARGET_SIGNAL_WAITING] = 0; 7202 signal_stop[TARGET_SIGNAL_CANCEL] = 0; 7203 signal_print[TARGET_SIGNAL_CANCEL] = 0; 7204 7205 /* Update cached state. */ 7206 signal_cache_update (-1); 7207 7208 add_setshow_zinteger_cmd ("stop-on-solib-events", class_support, 7209 &stop_on_solib_events, _("\ 7210 Set stopping for shared library events."), _("\ 7211 Show stopping for shared library events."), _("\ 7212 If nonzero, gdb will give control to the user when the dynamic linker\n\ 7213 notifies gdb of shared library events. The most common event of interest\n\ 7214 to the user would be loading/unloading of a new library."), 7215 NULL, 7216 show_stop_on_solib_events, 7217 &setlist, &showlist); 7218 7219 add_setshow_enum_cmd ("follow-fork-mode", class_run, 7220 follow_fork_mode_kind_names, 7221 &follow_fork_mode_string, _("\ 7222 Set debugger response to a program call of fork or vfork."), _("\ 7223 Show debugger response to a program call of fork or vfork."), _("\ 7224 A fork or vfork creates a new process. follow-fork-mode can be:\n\ 7225 parent - the original process is debugged after a fork\n\ 7226 child - the new process is debugged after a fork\n\ 7227 The unfollowed process will continue to run.\n\ 7228 By default, the debugger will follow the parent process."), 7229 NULL, 7230 show_follow_fork_mode_string, 7231 &setlist, &showlist); 7232 7233 add_setshow_enum_cmd ("follow-exec-mode", class_run, 7234 follow_exec_mode_names, 7235 &follow_exec_mode_string, _("\ 7236 Set debugger response to a program call of exec."), _("\ 7237 Show debugger response to a program call of exec."), _("\ 7238 An exec call replaces the program image of a process.\n\ 7239 \n\ 7240 follow-exec-mode can be:\n\ 7241 \n\ 7242 new - the debugger creates a new inferior and rebinds the process\n\ 7243 to this new inferior. The program the process was running before\n\ 7244 the exec call can be restarted afterwards by restarting the original\n\ 7245 inferior.\n\ 7246 \n\ 7247 same - the debugger keeps the process bound to the same inferior.\n\ 7248 The new executable image replaces the previous executable loaded in\n\ 7249 the inferior. Restarting the inferior after the exec call restarts\n\ 7250 the executable the process was running after the exec call.\n\ 7251 \n\ 7252 By default, the debugger will use the same inferior."), 7253 NULL, 7254 show_follow_exec_mode_string, 7255 &setlist, &showlist); 7256 7257 add_setshow_enum_cmd ("scheduler-locking", class_run, 7258 scheduler_enums, &scheduler_mode, _("\ 7259 Set mode for locking scheduler during execution."), _("\ 7260 Show mode for locking scheduler during execution."), _("\ 7261 off == no locking (threads may preempt at any time)\n\ 7262 on == full locking (no thread except the current thread may run)\n\ 7263 step == scheduler locked during every single-step operation.\n\ 7264 In this mode, no other thread may run during a step command.\n\ 7265 Other threads may run while stepping over a function call ('next')."), 7266 set_schedlock_func, /* traps on target vector */ 7267 show_scheduler_mode, 7268 &setlist, &showlist); 7269 7270 add_setshow_boolean_cmd ("schedule-multiple", class_run, &sched_multi, _("\ 7271 Set mode for resuming threads of all processes."), _("\ 7272 Show mode for resuming threads of all processes."), _("\ 7273 When on, execution commands (such as 'continue' or 'next') resume all\n\ 7274 threads of all processes. When off (which is the default), execution\n\ 7275 commands only resume the threads of the current process. The set of\n\ 7276 threads that are resumed is further refined by the scheduler-locking\n\ 7277 mode (see help set scheduler-locking)."), 7278 NULL, 7279 show_schedule_multiple, 7280 &setlist, &showlist); 7281 7282 add_setshow_boolean_cmd ("step-mode", class_run, &step_stop_if_no_debug, _("\ 7283 Set mode of the step operation."), _("\ 7284 Show mode of the step operation."), _("\ 7285 When set, doing a step over a function without debug line information\n\ 7286 will stop at the first instruction of that function. Otherwise, the\n\ 7287 function is skipped and the step command stops at a different source line."), 7288 NULL, 7289 show_step_stop_if_no_debug, 7290 &setlist, &showlist); 7291 7292 add_setshow_enum_cmd ("displaced-stepping", class_run, 7293 can_use_displaced_stepping_enum, 7294 &can_use_displaced_stepping, _("\ 7295 Set debugger's willingness to use displaced stepping."), _("\ 7296 Show debugger's willingness to use displaced stepping."), _("\ 7297 If on, gdb will use displaced stepping to step over breakpoints if it is\n\ 7298 supported by the target architecture. If off, gdb will not use displaced\n\ 7299 stepping to step over breakpoints, even if such is supported by the target\n\ 7300 architecture. If auto (which is the default), gdb will use displaced stepping\n\ 7301 if the target architecture supports it and non-stop mode is active, but will not\n\ 7302 use it in all-stop mode (see help set non-stop)."), 7303 NULL, 7304 show_can_use_displaced_stepping, 7305 &setlist, &showlist); 7306 7307 add_setshow_enum_cmd ("exec-direction", class_run, exec_direction_names, 7308 &exec_direction, _("Set direction of execution.\n\ 7309 Options are 'forward' or 'reverse'."), 7310 _("Show direction of execution (forward/reverse)."), 7311 _("Tells gdb whether to execute forward or backward."), 7312 set_exec_direction_func, show_exec_direction_func, 7313 &setlist, &showlist); 7314 7315 /* Set/show detach-on-fork: user-settable mode. */ 7316 7317 add_setshow_boolean_cmd ("detach-on-fork", class_run, &detach_fork, _("\ 7318 Set whether gdb will detach the child of a fork."), _("\ 7319 Show whether gdb will detach the child of a fork."), _("\ 7320 Tells gdb whether to detach the child of a fork."), 7321 NULL, NULL, &setlist, &showlist); 7322 7323 /* Set/show disable address space randomization mode. */ 7324 7325 add_setshow_boolean_cmd ("disable-randomization", class_support, 7326 &disable_randomization, _("\ 7327 Set disabling of debuggee's virtual address space randomization."), _("\ 7328 Show disabling of debuggee's virtual address space randomization."), _("\ 7329 When this mode is on (which is the default), randomization of the virtual\n\ 7330 address space is disabled. Standalone programs run with the randomization\n\ 7331 enabled by default on some platforms."), 7332 &set_disable_randomization, 7333 &show_disable_randomization, 7334 &setlist, &showlist); 7335 7336 /* ptid initializations */ 7337 inferior_ptid = null_ptid; 7338 target_last_wait_ptid = minus_one_ptid; 7339 7340 observer_attach_thread_ptid_changed (infrun_thread_ptid_changed); 7341 observer_attach_thread_stop_requested (infrun_thread_stop_requested); 7342 observer_attach_thread_exit (infrun_thread_thread_exit); 7343 observer_attach_inferior_exit (infrun_inferior_exit); 7344 7345 /* Explicitly create without lookup, since that tries to create a 7346 value with a void typed value, and when we get here, gdbarch 7347 isn't initialized yet. At this point, we're quite sure there 7348 isn't another convenience variable of the same name. */ 7349 create_internalvar_type_lazy ("_siginfo", siginfo_make_value); 7350 7351 add_setshow_boolean_cmd ("observer", no_class, 7352 &observer_mode_1, _("\ 7353 Set whether gdb controls the inferior in observer mode."), _("\ 7354 Show whether gdb controls the inferior in observer mode."), _("\ 7355 In observer mode, GDB can get data from the inferior, but not\n\ 7356 affect its execution. Registers and memory may not be changed,\n\ 7357 breakpoints may not be set, and the program cannot be interrupted\n\ 7358 or signalled."), 7359 set_observer_mode, 7360 show_observer_mode, 7361 &setlist, 7362 &showlist); 7363 } 7364