1/* Target-struct-independent code to start (run) and stop an inferior 2 process. 3 4 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 5 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free 6 Software Foundation, Inc. 7 8 This file is part of GDB. 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 2 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program; if not, write to the Free Software 22 Foundation, Inc., 59 Temple Place - Suite 330, 23 Boston, MA 02111-1307, USA. */ 24 25#include "defs.h" 26#include "gdb_string.h" 27#include <ctype.h> 28#include "symtab.h" 29#include "frame.h" 30#include "inferior.h" 31#include "breakpoint.h" 32#include "gdb_wait.h" 33#include "gdbcore.h" 34#include "gdbcmd.h" 35#include "cli/cli-script.h" 36#include "target.h" 37#include "gdbthread.h" 38#include "annotate.h" 39#include "symfile.h" 40#include "top.h" 41#include <signal.h> 42#include "inf-loop.h" 43#include "regcache.h" 44#include "value.h" 45#include "observer.h" 46#include "language.h" 47#include "gdb_assert.h" 48 49/* Prototypes for local functions */ 50 51static void signals_info (char *, int); 52 53static void handle_command (char *, int); 54 55static void sig_print_info (enum target_signal); 56 57static void sig_print_header (void); 58 59static void resume_cleanups (void *); 60 61static int hook_stop_stub (void *); 62 63static int restore_selected_frame (void *); 64 65static void build_infrun (void); 66 67static int follow_fork (void); 68 69static void set_schedlock_func (char *args, int from_tty, 70 struct cmd_list_element *c); 71 72struct execution_control_state; 73 74static int currently_stepping (struct execution_control_state *ecs); 75 76static void xdb_handle_command (char *args, int from_tty); 77 78static int prepare_to_proceed (void); 79 80void _initialize_infrun (void); 81 82int inferior_ignoring_startup_exec_events = 0; 83int inferior_ignoring_leading_exec_events = 0; 84 85/* When set, stop the 'step' command if we enter a function which has 86 no line number information. The normal behavior is that we step 87 over such function. */ 88int step_stop_if_no_debug = 0; 89 90/* In asynchronous mode, but simulating synchronous execution. */ 91 92int sync_execution = 0; 93 94/* wait_for_inferior and normal_stop use this to notify the user 95 when the inferior stopped in a different thread than it had been 96 running in. */ 97 98static ptid_t previous_inferior_ptid; 99 100/* This is true for configurations that may follow through execl() and 101 similar functions. At present this is only true for HP-UX native. */ 102 103#ifndef MAY_FOLLOW_EXEC 104#define MAY_FOLLOW_EXEC (0) 105#endif 106 107static int may_follow_exec = MAY_FOLLOW_EXEC; 108 109/* If the program uses ELF-style shared libraries, then calls to 110 functions in shared libraries go through stubs, which live in a 111 table called the PLT (Procedure Linkage Table). The first time the 112 function is called, the stub sends control to the dynamic linker, 113 which looks up the function's real address, patches the stub so 114 that future calls will go directly to the function, and then passes 115 control to the function. 116 117 If we are stepping at the source level, we don't want to see any of 118 this --- we just want to skip over the stub and the dynamic linker. 119 The simple approach is to single-step until control leaves the 120 dynamic linker. 121 122 However, on some systems (e.g., Red Hat's 5.2 distribution) the 123 dynamic linker calls functions in the shared C library, so you 124 can't tell from the PC alone whether the dynamic linker is still 125 running. In this case, we use a step-resume breakpoint to get us 126 past the dynamic linker, as if we were using "next" to step over a 127 function call. 128 129 IN_SOLIB_DYNSYM_RESOLVE_CODE says whether we're in the dynamic 130 linker code or not. Normally, this means we single-step. However, 131 if SKIP_SOLIB_RESOLVER then returns non-zero, then its value is an 132 address where we can place a step-resume breakpoint to get past the 133 linker's symbol resolution function. 134 135 IN_SOLIB_DYNSYM_RESOLVE_CODE can generally be implemented in a 136 pretty portable way, by comparing the PC against the address ranges 137 of the dynamic linker's sections. 138 139 SKIP_SOLIB_RESOLVER is generally going to be system-specific, since 140 it depends on internal details of the dynamic linker. It's usually 141 not too hard to figure out where to put a breakpoint, but it 142 certainly isn't portable. SKIP_SOLIB_RESOLVER should do plenty of 143 sanity checking. If it can't figure things out, returning zero and 144 getting the (possibly confusing) stepping behavior is better than 145 signalling an error, which will obscure the change in the 146 inferior's state. */ 147 148#ifndef IN_SOLIB_DYNSYM_RESOLVE_CODE 149#define IN_SOLIB_DYNSYM_RESOLVE_CODE(pc) 0 150#endif 151 152/* This function returns TRUE if pc is the address of an instruction 153 that lies within the dynamic linker (such as the event hook, or the 154 dld itself). 155 156 This function must be used only when a dynamic linker event has 157 been caught, and the inferior is being stepped out of the hook, or 158 undefined results are guaranteed. */ 159 160#ifndef SOLIB_IN_DYNAMIC_LINKER 161#define SOLIB_IN_DYNAMIC_LINKER(pid,pc) 0 162#endif 163 164/* On some systems, the PC may be left pointing at an instruction that won't 165 actually be executed. This is usually indicated by a bit in the PSW. If 166 we find ourselves in such a state, then we step the target beyond the 167 nullified instruction before returning control to the user so as to avoid 168 confusion. */ 169 170#ifndef INSTRUCTION_NULLIFIED 171#define INSTRUCTION_NULLIFIED 0 172#endif 173 174/* We can't step off a permanent breakpoint in the ordinary way, because we 175 can't remove it. Instead, we have to advance the PC to the next 176 instruction. This macro should expand to a pointer to a function that 177 does that, or zero if we have no such function. If we don't have a 178 definition for it, we have to report an error. */ 179#ifndef SKIP_PERMANENT_BREAKPOINT 180#define SKIP_PERMANENT_BREAKPOINT (default_skip_permanent_breakpoint) 181static void 182default_skip_permanent_breakpoint (void) 183{ 184 error ("\ 185The program is stopped at a permanent breakpoint, but GDB does not know\n\ 186how to step past a permanent breakpoint on this architecture. Try using\n\ 187a command like `return' or `jump' to continue execution."); 188} 189#endif 190 191 192/* Convert the #defines into values. This is temporary until wfi control 193 flow is completely sorted out. */ 194 195#ifndef HAVE_STEPPABLE_WATCHPOINT 196#define HAVE_STEPPABLE_WATCHPOINT 0 197#else 198#undef HAVE_STEPPABLE_WATCHPOINT 199#define HAVE_STEPPABLE_WATCHPOINT 1 200#endif 201 202#ifndef CANNOT_STEP_HW_WATCHPOINTS 203#define CANNOT_STEP_HW_WATCHPOINTS 0 204#else 205#undef CANNOT_STEP_HW_WATCHPOINTS 206#define CANNOT_STEP_HW_WATCHPOINTS 1 207#endif 208 209/* Tables of how to react to signals; the user sets them. */ 210 211static unsigned char *signal_stop; 212static unsigned char *signal_print; 213static unsigned char *signal_program; 214 215#define SET_SIGS(nsigs,sigs,flags) \ 216 do { \ 217 int signum = (nsigs); \ 218 while (signum-- > 0) \ 219 if ((sigs)[signum]) \ 220 (flags)[signum] = 1; \ 221 } while (0) 222 223#define UNSET_SIGS(nsigs,sigs,flags) \ 224 do { \ 225 int signum = (nsigs); \ 226 while (signum-- > 0) \ 227 if ((sigs)[signum]) \ 228 (flags)[signum] = 0; \ 229 } while (0) 230 231/* Value to pass to target_resume() to cause all threads to resume */ 232 233#define RESUME_ALL (pid_to_ptid (-1)) 234 235/* Command list pointer for the "stop" placeholder. */ 236 237static struct cmd_list_element *stop_command; 238 239/* Nonzero if breakpoints are now inserted in the inferior. */ 240 241static int breakpoints_inserted; 242 243/* Function inferior was in as of last step command. */ 244 245static struct symbol *step_start_function; 246 247/* Nonzero if we are expecting a trace trap and should proceed from it. */ 248 249static int trap_expected; 250 251#ifdef SOLIB_ADD 252/* Nonzero if we want to give control to the user when we're notified 253 of shared library events by the dynamic linker. */ 254static int stop_on_solib_events; 255#endif 256 257/* Nonzero means expecting a trace trap 258 and should stop the inferior and return silently when it happens. */ 259 260int stop_after_trap; 261 262/* Nonzero means expecting a trap and caller will handle it themselves. 263 It is used after attach, due to attaching to a process; 264 when running in the shell before the child program has been exec'd; 265 and when running some kinds of remote stuff (FIXME?). */ 266 267enum stop_kind stop_soon; 268 269/* Nonzero if proceed is being used for a "finish" command or a similar 270 situation when stop_registers should be saved. */ 271 272int proceed_to_finish; 273 274/* Save register contents here when about to pop a stack dummy frame, 275 if-and-only-if proceed_to_finish is set. 276 Thus this contains the return value from the called function (assuming 277 values are returned in a register). */ 278 279struct regcache *stop_registers; 280 281/* Nonzero if program stopped due to error trying to insert breakpoints. */ 282 283static int breakpoints_failed; 284 285/* Nonzero after stop if current stack frame should be printed. */ 286 287static int stop_print_frame; 288 289static struct breakpoint *step_resume_breakpoint = NULL; 290 291/* On some platforms (e.g., HP-UX), hardware watchpoints have bad 292 interactions with an inferior that is running a kernel function 293 (aka, a system call or "syscall"). wait_for_inferior therefore 294 may have a need to know when the inferior is in a syscall. This 295 is a count of the number of inferior threads which are known to 296 currently be running in a syscall. */ 297static int number_of_threads_in_syscalls; 298 299/* This is a cached copy of the pid/waitstatus of the last event 300 returned by target_wait()/deprecated_target_wait_hook(). This 301 information is returned by get_last_target_status(). */ 302static ptid_t target_last_wait_ptid; 303static struct target_waitstatus target_last_waitstatus; 304 305/* This is used to remember when a fork, vfork or exec event 306 was caught by a catchpoint, and thus the event is to be 307 followed at the next resume of the inferior, and not 308 immediately. */ 309static struct 310{ 311 enum target_waitkind kind; 312 struct 313 { 314 int parent_pid; 315 int child_pid; 316 } 317 fork_event; 318 char *execd_pathname; 319} 320pending_follow; 321 322static const char follow_fork_mode_child[] = "child"; 323static const char follow_fork_mode_parent[] = "parent"; 324 325static const char *follow_fork_mode_kind_names[] = { 326 follow_fork_mode_child, 327 follow_fork_mode_parent, 328 NULL 329}; 330 331static const char *follow_fork_mode_string = follow_fork_mode_parent; 332 333 334static int 335follow_fork (void) 336{ 337 int follow_child = (follow_fork_mode_string == follow_fork_mode_child); 338 339 return target_follow_fork (follow_child); 340} 341 342void 343follow_inferior_reset_breakpoints (void) 344{ 345 /* Was there a step_resume breakpoint? (There was if the user 346 did a "next" at the fork() call.) If so, explicitly reset its 347 thread number. 348 349 step_resumes are a form of bp that are made to be per-thread. 350 Since we created the step_resume bp when the parent process 351 was being debugged, and now are switching to the child process, 352 from the breakpoint package's viewpoint, that's a switch of 353 "threads". We must update the bp's notion of which thread 354 it is for, or it'll be ignored when it triggers. */ 355 356 if (step_resume_breakpoint) 357 breakpoint_re_set_thread (step_resume_breakpoint); 358 359 /* Reinsert all breakpoints in the child. The user may have set 360 breakpoints after catching the fork, in which case those 361 were never set in the child, but only in the parent. This makes 362 sure the inserted breakpoints match the breakpoint list. */ 363 364 breakpoint_re_set (); 365 insert_breakpoints (); 366} 367 368/* EXECD_PATHNAME is assumed to be non-NULL. */ 369 370static void 371follow_exec (int pid, char *execd_pathname) 372{ 373 int saved_pid = pid; 374 struct target_ops *tgt; 375 376 if (!may_follow_exec) 377 return; 378 379 /* This is an exec event that we actually wish to pay attention to. 380 Refresh our symbol table to the newly exec'd program, remove any 381 momentary bp's, etc. 382 383 If there are breakpoints, they aren't really inserted now, 384 since the exec() transformed our inferior into a fresh set 385 of instructions. 386 387 We want to preserve symbolic breakpoints on the list, since 388 we have hopes that they can be reset after the new a.out's 389 symbol table is read. 390 391 However, any "raw" breakpoints must be removed from the list 392 (e.g., the solib bp's), since their address is probably invalid 393 now. 394 395 And, we DON'T want to call delete_breakpoints() here, since 396 that may write the bp's "shadow contents" (the instruction 397 value that was overwritten witha TRAP instruction). Since 398 we now have a new a.out, those shadow contents aren't valid. */ 399 update_breakpoints_after_exec (); 400 401 /* If there was one, it's gone now. We cannot truly step-to-next 402 statement through an exec(). */ 403 step_resume_breakpoint = NULL; 404 step_range_start = 0; 405 step_range_end = 0; 406 407 /* What is this a.out's name? */ 408 printf_unfiltered ("Executing new program: %s\n", execd_pathname); 409 410 /* We've followed the inferior through an exec. Therefore, the 411 inferior has essentially been killed & reborn. */ 412 413 /* First collect the run target in effect. */ 414 tgt = find_run_target (); 415 /* If we can't find one, things are in a very strange state... */ 416 if (tgt == NULL) 417 error ("Could find run target to save before following exec"); 418 419 gdb_flush (gdb_stdout); 420 target_mourn_inferior (); 421 inferior_ptid = pid_to_ptid (saved_pid); 422 /* Because mourn_inferior resets inferior_ptid. */ 423 push_target (tgt); 424 425 /* That a.out is now the one to use. */ 426 exec_file_attach (execd_pathname, 0); 427 428 /* And also is where symbols can be found. */ 429 symbol_file_add_main (execd_pathname, 0); 430 431 /* Reset the shared library package. This ensures that we get 432 a shlib event when the child reaches "_start", at which point 433 the dld will have had a chance to initialize the child. */ 434#if defined(SOLIB_RESTART) 435 SOLIB_RESTART (); 436#endif 437#ifdef SOLIB_CREATE_INFERIOR_HOOK 438 SOLIB_CREATE_INFERIOR_HOOK (PIDGET (inferior_ptid)); 439#endif 440 441 /* Reinsert all breakpoints. (Those which were symbolic have 442 been reset to the proper address in the new a.out, thanks 443 to symbol_file_command...) */ 444 insert_breakpoints (); 445 446 /* The next resume of this inferior should bring it to the shlib 447 startup breakpoints. (If the user had also set bp's on 448 "main" from the old (parent) process, then they'll auto- 449 matically get reset there in the new process.) */ 450} 451 452/* Non-zero if we just simulating a single-step. This is needed 453 because we cannot remove the breakpoints in the inferior process 454 until after the `wait' in `wait_for_inferior'. */ 455static int singlestep_breakpoints_inserted_p = 0; 456 457/* The thread we inserted single-step breakpoints for. */ 458static ptid_t singlestep_ptid; 459 460/* If another thread hit the singlestep breakpoint, we save the original 461 thread here so that we can resume single-stepping it later. */ 462static ptid_t saved_singlestep_ptid; 463static int stepping_past_singlestep_breakpoint; 464 465 466/* Things to clean up if we QUIT out of resume (). */ 467static void 468resume_cleanups (void *ignore) 469{ 470 normal_stop (); 471} 472 473static const char schedlock_off[] = "off"; 474static const char schedlock_on[] = "on"; 475static const char schedlock_step[] = "step"; 476static const char *scheduler_mode = schedlock_off; 477static const char *scheduler_enums[] = { 478 schedlock_off, 479 schedlock_on, 480 schedlock_step, 481 NULL 482}; 483 484static void 485set_schedlock_func (char *args, int from_tty, struct cmd_list_element *c) 486{ 487 /* NOTE: cagney/2002-03-17: The deprecated_add_show_from_set() 488 function clones the set command passed as a parameter. The clone 489 operation will include (BUG?) any ``set'' command callback, if 490 present. Commands like ``info set'' call all the ``show'' 491 command callbacks. Unfortunately, for ``show'' commands cloned 492 from ``set'', this includes callbacks belonging to ``set'' 493 commands. Making this worse, this only occures if 494 deprecated_add_show_from_set() is called after add_cmd_sfunc() 495 (BUG?). */ 496 if (cmd_type (c) == set_cmd) 497 if (!target_can_lock_scheduler) 498 { 499 scheduler_mode = schedlock_off; 500 error ("Target '%s' cannot support this command.", target_shortname); 501 } 502} 503 504 505/* Resume the inferior, but allow a QUIT. This is useful if the user 506 wants to interrupt some lengthy single-stepping operation 507 (for child processes, the SIGINT goes to the inferior, and so 508 we get a SIGINT random_signal, but for remote debugging and perhaps 509 other targets, that's not true). 510 511 STEP nonzero if we should step (zero to continue instead). 512 SIG is the signal to give the inferior (zero for none). */ 513void 514resume (int step, enum target_signal sig) 515{ 516 int should_resume = 1; 517 struct cleanup *old_cleanups = make_cleanup (resume_cleanups, 0); 518 QUIT; 519 520 /* FIXME: calling breakpoint_here_p (read_pc ()) three times! */ 521 522 523 /* Some targets (e.g. Solaris x86) have a kernel bug when stepping 524 over an instruction that causes a page fault without triggering 525 a hardware watchpoint. The kernel properly notices that it shouldn't 526 stop, because the hardware watchpoint is not triggered, but it forgets 527 the step request and continues the program normally. 528 Work around the problem by removing hardware watchpoints if a step is 529 requested, GDB will check for a hardware watchpoint trigger after the 530 step anyway. */ 531 if (CANNOT_STEP_HW_WATCHPOINTS && step && breakpoints_inserted) 532 remove_hw_watchpoints (); 533 534 535 /* Normally, by the time we reach `resume', the breakpoints are either 536 removed or inserted, as appropriate. The exception is if we're sitting 537 at a permanent breakpoint; we need to step over it, but permanent 538 breakpoints can't be removed. So we have to test for it here. */ 539 if (breakpoint_here_p (read_pc ()) == permanent_breakpoint_here) 540 SKIP_PERMANENT_BREAKPOINT (); 541 542 if (SOFTWARE_SINGLE_STEP_P () && step) 543 { 544 /* Do it the hard way, w/temp breakpoints */ 545 SOFTWARE_SINGLE_STEP (sig, 1 /*insert-breakpoints */ ); 546 /* ...and don't ask hardware to do it. */ 547 step = 0; 548 /* and do not pull these breakpoints until after a `wait' in 549 `wait_for_inferior' */ 550 singlestep_breakpoints_inserted_p = 1; 551 singlestep_ptid = inferior_ptid; 552 } 553 554 /* If there were any forks/vforks/execs that were caught and are 555 now to be followed, then do so. */ 556 switch (pending_follow.kind) 557 { 558 case TARGET_WAITKIND_FORKED: 559 case TARGET_WAITKIND_VFORKED: 560 pending_follow.kind = TARGET_WAITKIND_SPURIOUS; 561 if (follow_fork ()) 562 should_resume = 0; 563 break; 564 565 case TARGET_WAITKIND_EXECD: 566 /* follow_exec is called as soon as the exec event is seen. */ 567 pending_follow.kind = TARGET_WAITKIND_SPURIOUS; 568 break; 569 570 default: 571 break; 572 } 573 574 /* Install inferior's terminal modes. */ 575 target_terminal_inferior (); 576 577 if (should_resume) 578 { 579 ptid_t resume_ptid; 580 581 resume_ptid = RESUME_ALL; /* Default */ 582 583 if ((step || singlestep_breakpoints_inserted_p) 584 && (stepping_past_singlestep_breakpoint 585 || (!breakpoints_inserted && breakpoint_here_p (read_pc ())))) 586 { 587 /* Stepping past a breakpoint without inserting breakpoints. 588 Make sure only the current thread gets to step, so that 589 other threads don't sneak past breakpoints while they are 590 not inserted. */ 591 592 resume_ptid = inferior_ptid; 593 } 594 595 if ((scheduler_mode == schedlock_on) 596 || (scheduler_mode == schedlock_step 597 && (step || singlestep_breakpoints_inserted_p))) 598 { 599 /* User-settable 'scheduler' mode requires solo thread resume. */ 600 resume_ptid = inferior_ptid; 601 } 602 603 if (CANNOT_STEP_BREAKPOINT) 604 { 605 /* Most targets can step a breakpoint instruction, thus 606 executing it normally. But if this one cannot, just 607 continue and we will hit it anyway. */ 608 if (step && breakpoints_inserted && breakpoint_here_p (read_pc ())) 609 step = 0; 610 } 611 target_resume (resume_ptid, step, sig); 612 } 613 614 discard_cleanups (old_cleanups); 615} 616 617 618/* Clear out all variables saying what to do when inferior is continued. 619 First do this, then set the ones you want, then call `proceed'. */ 620 621void 622clear_proceed_status (void) 623{ 624 trap_expected = 0; 625 step_range_start = 0; 626 step_range_end = 0; 627 step_frame_id = null_frame_id; 628 step_over_calls = STEP_OVER_UNDEBUGGABLE; 629 stop_after_trap = 0; 630 stop_soon = NO_STOP_QUIETLY; 631 proceed_to_finish = 0; 632 breakpoint_proceeded = 1; /* We're about to proceed... */ 633 634 /* Discard any remaining commands or status from previous stop. */ 635 bpstat_clear (&stop_bpstat); 636} 637 638/* This should be suitable for any targets that support threads. */ 639 640static int 641prepare_to_proceed (void) 642{ 643 ptid_t wait_ptid; 644 struct target_waitstatus wait_status; 645 646 /* Get the last target status returned by target_wait(). */ 647 get_last_target_status (&wait_ptid, &wait_status); 648 649 /* Make sure we were stopped either at a breakpoint, or because 650 of a Ctrl-C. */ 651 if (wait_status.kind != TARGET_WAITKIND_STOPPED 652 || (wait_status.value.sig != TARGET_SIGNAL_TRAP 653 && wait_status.value.sig != TARGET_SIGNAL_INT)) 654 { 655 return 0; 656 } 657 658 if (!ptid_equal (wait_ptid, minus_one_ptid) 659 && !ptid_equal (inferior_ptid, wait_ptid)) 660 { 661 /* Switched over from WAIT_PID. */ 662 CORE_ADDR wait_pc = read_pc_pid (wait_ptid); 663 664 if (wait_pc != read_pc ()) 665 { 666 /* Switch back to WAIT_PID thread. */ 667 inferior_ptid = wait_ptid; 668 669 /* FIXME: This stuff came from switch_to_thread() in 670 thread.c (which should probably be a public function). */ 671 flush_cached_frames (); 672 registers_changed (); 673 stop_pc = wait_pc; 674 select_frame (get_current_frame ()); 675 } 676 677 /* We return 1 to indicate that there is a breakpoint here, 678 so we need to step over it before continuing to avoid 679 hitting it straight away. */ 680 if (breakpoint_here_p (wait_pc)) 681 return 1; 682 } 683 684 return 0; 685 686} 687 688/* Record the pc of the program the last time it stopped. This is 689 just used internally by wait_for_inferior, but need to be preserved 690 over calls to it and cleared when the inferior is started. */ 691static CORE_ADDR prev_pc; 692 693/* Basic routine for continuing the program in various fashions. 694 695 ADDR is the address to resume at, or -1 for resume where stopped. 696 SIGGNAL is the signal to give it, or 0 for none, 697 or -1 for act according to how it stopped. 698 STEP is nonzero if should trap after one instruction. 699 -1 means return after that and print nothing. 700 You should probably set various step_... variables 701 before calling here, if you are stepping. 702 703 You should call clear_proceed_status before calling proceed. */ 704 705void 706proceed (CORE_ADDR addr, enum target_signal siggnal, int step) 707{ 708 int oneproc = 0; 709 710 if (step > 0) 711 step_start_function = find_pc_function (read_pc ()); 712 if (step < 0) 713 stop_after_trap = 1; 714 715 if (addr == (CORE_ADDR) -1) 716 { 717 /* If there is a breakpoint at the address we will resume at, 718 step one instruction before inserting breakpoints 719 so that we do not stop right away (and report a second 720 hit at this breakpoint). */ 721 722 if (read_pc () == stop_pc && breakpoint_here_p (read_pc ())) 723 oneproc = 1; 724 725#ifndef STEP_SKIPS_DELAY 726#define STEP_SKIPS_DELAY(pc) (0) 727#define STEP_SKIPS_DELAY_P (0) 728#endif 729 /* Check breakpoint_here_p first, because breakpoint_here_p is fast 730 (it just checks internal GDB data structures) and STEP_SKIPS_DELAY 731 is slow (it needs to read memory from the target). */ 732 if (STEP_SKIPS_DELAY_P 733 && breakpoint_here_p (read_pc () + 4) 734 && STEP_SKIPS_DELAY (read_pc ())) 735 oneproc = 1; 736 } 737 else 738 { 739 write_pc (addr); 740 } 741 742 /* In a multi-threaded task we may select another thread 743 and then continue or step. 744 745 But if the old thread was stopped at a breakpoint, it 746 will immediately cause another breakpoint stop without 747 any execution (i.e. it will report a breakpoint hit 748 incorrectly). So we must step over it first. 749 750 prepare_to_proceed checks the current thread against the thread 751 that reported the most recent event. If a step-over is required 752 it returns TRUE and sets the current thread to the old thread. */ 753 if (prepare_to_proceed () && breakpoint_here_p (read_pc ())) 754 oneproc = 1; 755 756 if (oneproc) 757 /* We will get a trace trap after one instruction. 758 Continue it automatically and insert breakpoints then. */ 759 trap_expected = 1; 760 else 761 { 762 insert_breakpoints (); 763 /* If we get here there was no call to error() in 764 insert breakpoints -- so they were inserted. */ 765 breakpoints_inserted = 1; 766 } 767 768 if (siggnal != TARGET_SIGNAL_DEFAULT) 769 stop_signal = siggnal; 770 /* If this signal should not be seen by program, 771 give it zero. Used for debugging signals. */ 772 else if (!signal_program[stop_signal]) 773 stop_signal = TARGET_SIGNAL_0; 774 775 annotate_starting (); 776 777 /* Make sure that output from GDB appears before output from the 778 inferior. */ 779 gdb_flush (gdb_stdout); 780 781 /* Refresh prev_pc value just prior to resuming. This used to be 782 done in stop_stepping, however, setting prev_pc there did not handle 783 scenarios such as inferior function calls or returning from 784 a function via the return command. In those cases, the prev_pc 785 value was not set properly for subsequent commands. The prev_pc value 786 is used to initialize the starting line number in the ecs. With an 787 invalid value, the gdb next command ends up stopping at the position 788 represented by the next line table entry past our start position. 789 On platforms that generate one line table entry per line, this 790 is not a problem. However, on the ia64, the compiler generates 791 extraneous line table entries that do not increase the line number. 792 When we issue the gdb next command on the ia64 after an inferior call 793 or a return command, we often end up a few instructions forward, still 794 within the original line we started. 795 796 An attempt was made to have init_execution_control_state () refresh 797 the prev_pc value before calculating the line number. This approach 798 did not work because on platforms that use ptrace, the pc register 799 cannot be read unless the inferior is stopped. At that point, we 800 are not guaranteed the inferior is stopped and so the read_pc () 801 call can fail. Setting the prev_pc value here ensures the value is 802 updated correctly when the inferior is stopped. */ 803 prev_pc = read_pc (); 804 805 /* Resume inferior. */ 806 resume (oneproc || step || bpstat_should_step (), stop_signal); 807 808 /* Wait for it to stop (if not standalone) 809 and in any case decode why it stopped, and act accordingly. */ 810 /* Do this only if we are not using the event loop, or if the target 811 does not support asynchronous execution. */ 812 if (!target_can_async_p ()) 813 { 814 wait_for_inferior (); 815 normal_stop (); 816 } 817} 818 819 820/* Start remote-debugging of a machine over a serial link. */ 821 822void 823start_remote (void) 824{ 825 init_thread_list (); 826 init_wait_for_inferior (); 827 stop_soon = STOP_QUIETLY; 828 trap_expected = 0; 829 830 /* Always go on waiting for the target, regardless of the mode. */ 831 /* FIXME: cagney/1999-09-23: At present it isn't possible to 832 indicate to wait_for_inferior that a target should timeout if 833 nothing is returned (instead of just blocking). Because of this, 834 targets expecting an immediate response need to, internally, set 835 things up so that the target_wait() is forced to eventually 836 timeout. */ 837 /* FIXME: cagney/1999-09-24: It isn't possible for target_open() to 838 differentiate to its caller what the state of the target is after 839 the initial open has been performed. Here we're assuming that 840 the target has stopped. It should be possible to eventually have 841 target_open() return to the caller an indication that the target 842 is currently running and GDB state should be set to the same as 843 for an async run. */ 844 wait_for_inferior (); 845 normal_stop (); 846} 847 848/* Initialize static vars when a new inferior begins. */ 849 850void 851init_wait_for_inferior (void) 852{ 853 /* These are meaningless until the first time through wait_for_inferior. */ 854 prev_pc = 0; 855 856 breakpoints_inserted = 0; 857 breakpoint_init_inferior (inf_starting); 858 859 /* Don't confuse first call to proceed(). */ 860 stop_signal = TARGET_SIGNAL_0; 861 862 /* The first resume is not following a fork/vfork/exec. */ 863 pending_follow.kind = TARGET_WAITKIND_SPURIOUS; /* I.e., none. */ 864 865 /* See wait_for_inferior's handling of SYSCALL_ENTRY/RETURN events. */ 866 number_of_threads_in_syscalls = 0; 867 868 clear_proceed_status (); 869 870 stepping_past_singlestep_breakpoint = 0; 871} 872 873/* This enum encodes possible reasons for doing a target_wait, so that 874 wfi can call target_wait in one place. (Ultimately the call will be 875 moved out of the infinite loop entirely.) */ 876 877enum infwait_states 878{ 879 infwait_normal_state, 880 infwait_thread_hop_state, 881 infwait_nullified_state, 882 infwait_nonstep_watch_state 883}; 884 885/* Why did the inferior stop? Used to print the appropriate messages 886 to the interface from within handle_inferior_event(). */ 887enum inferior_stop_reason 888{ 889 /* We don't know why. */ 890 STOP_UNKNOWN, 891 /* Step, next, nexti, stepi finished. */ 892 END_STEPPING_RANGE, 893 /* Found breakpoint. */ 894 BREAKPOINT_HIT, 895 /* Inferior terminated by signal. */ 896 SIGNAL_EXITED, 897 /* Inferior exited. */ 898 EXITED, 899 /* Inferior received signal, and user asked to be notified. */ 900 SIGNAL_RECEIVED 901}; 902 903/* This structure contains what used to be local variables in 904 wait_for_inferior. Probably many of them can return to being 905 locals in handle_inferior_event. */ 906 907struct execution_control_state 908{ 909 struct target_waitstatus ws; 910 struct target_waitstatus *wp; 911 int another_trap; 912 int random_signal; 913 CORE_ADDR stop_func_start; 914 CORE_ADDR stop_func_end; 915 char *stop_func_name; 916 struct symtab_and_line sal; 917 int current_line; 918 struct symtab *current_symtab; 919 int handling_longjmp; /* FIXME */ 920 ptid_t ptid; 921 ptid_t saved_inferior_ptid; 922 int step_after_step_resume_breakpoint; 923 int stepping_through_solib_after_catch; 924 bpstat stepping_through_solib_catchpoints; 925 int enable_hw_watchpoints_after_wait; 926 int new_thread_event; 927 struct target_waitstatus tmpstatus; 928 enum infwait_states infwait_state; 929 ptid_t waiton_ptid; 930 int wait_some_more; 931}; 932 933void init_execution_control_state (struct execution_control_state *ecs); 934 935void handle_inferior_event (struct execution_control_state *ecs); 936 937static void step_into_function (struct execution_control_state *ecs); 938static void insert_step_resume_breakpoint_at_frame (struct frame_info *step_frame); 939static void insert_step_resume_breakpoint_at_sal (struct symtab_and_line sr_sal, 940 struct frame_id sr_id); 941static void stop_stepping (struct execution_control_state *ecs); 942static void prepare_to_wait (struct execution_control_state *ecs); 943static void keep_going (struct execution_control_state *ecs); 944static void print_stop_reason (enum inferior_stop_reason stop_reason, 945 int stop_info); 946 947/* Wait for control to return from inferior to debugger. 948 If inferior gets a signal, we may decide to start it up again 949 instead of returning. That is why there is a loop in this function. 950 When this function actually returns it means the inferior 951 should be left stopped and GDB should read more commands. */ 952 953void 954wait_for_inferior (void) 955{ 956 struct cleanup *old_cleanups; 957 struct execution_control_state ecss; 958 struct execution_control_state *ecs; 959 960 old_cleanups = make_cleanup (delete_step_resume_breakpoint, 961 &step_resume_breakpoint); 962 963 /* wfi still stays in a loop, so it's OK just to take the address of 964 a local to get the ecs pointer. */ 965 ecs = &ecss; 966 967 /* Fill in with reasonable starting values. */ 968 init_execution_control_state (ecs); 969 970 /* We'll update this if & when we switch to a new thread. */ 971 previous_inferior_ptid = inferior_ptid; 972 973 overlay_cache_invalid = 1; 974 975 /* We have to invalidate the registers BEFORE calling target_wait 976 because they can be loaded from the target while in target_wait. 977 This makes remote debugging a bit more efficient for those 978 targets that provide critical registers as part of their normal 979 status mechanism. */ 980 981 registers_changed (); 982 983 while (1) 984 { 985 if (deprecated_target_wait_hook) 986 ecs->ptid = deprecated_target_wait_hook (ecs->waiton_ptid, ecs->wp); 987 else 988 ecs->ptid = target_wait (ecs->waiton_ptid, ecs->wp); 989 990 /* Now figure out what to do with the result of the result. */ 991 handle_inferior_event (ecs); 992 993 if (!ecs->wait_some_more) 994 break; 995 } 996 do_cleanups (old_cleanups); 997} 998 999/* Asynchronous version of wait_for_inferior. It is called by the 1000 event loop whenever a change of state is detected on the file 1001 descriptor corresponding to the target. It can be called more than 1002 once to complete a single execution command. In such cases we need 1003 to keep the state in a global variable ASYNC_ECSS. If it is the 1004 last time that this function is called for a single execution 1005 command, then report to the user that the inferior has stopped, and 1006 do the necessary cleanups. */ 1007 1008struct execution_control_state async_ecss; 1009struct execution_control_state *async_ecs; 1010 1011void 1012fetch_inferior_event (void *client_data) 1013{ 1014 static struct cleanup *old_cleanups; 1015 1016 async_ecs = &async_ecss; 1017 1018 if (!async_ecs->wait_some_more) 1019 { 1020 old_cleanups = make_exec_cleanup (delete_step_resume_breakpoint, 1021 &step_resume_breakpoint); 1022 1023 /* Fill in with reasonable starting values. */ 1024 init_execution_control_state (async_ecs); 1025 1026 /* We'll update this if & when we switch to a new thread. */ 1027 previous_inferior_ptid = inferior_ptid; 1028 1029 overlay_cache_invalid = 1; 1030 1031 /* We have to invalidate the registers BEFORE calling target_wait 1032 because they can be loaded from the target while in target_wait. 1033 This makes remote debugging a bit more efficient for those 1034 targets that provide critical registers as part of their normal 1035 status mechanism. */ 1036 1037 registers_changed (); 1038 } 1039 1040 if (deprecated_target_wait_hook) 1041 async_ecs->ptid = 1042 deprecated_target_wait_hook (async_ecs->waiton_ptid, async_ecs->wp); 1043 else 1044 async_ecs->ptid = target_wait (async_ecs->waiton_ptid, async_ecs->wp); 1045 1046 /* Now figure out what to do with the result of the result. */ 1047 handle_inferior_event (async_ecs); 1048 1049 if (!async_ecs->wait_some_more) 1050 { 1051 /* Do only the cleanups that have been added by this 1052 function. Let the continuations for the commands do the rest, 1053 if there are any. */ 1054 do_exec_cleanups (old_cleanups); 1055 normal_stop (); 1056 if (step_multi && stop_step) 1057 inferior_event_handler (INF_EXEC_CONTINUE, NULL); 1058 else 1059 inferior_event_handler (INF_EXEC_COMPLETE, NULL); 1060 } 1061} 1062 1063/* Prepare an execution control state for looping through a 1064 wait_for_inferior-type loop. */ 1065 1066void 1067init_execution_control_state (struct execution_control_state *ecs) 1068{ 1069 /* ecs->another_trap? */ 1070 ecs->random_signal = 0; 1071 ecs->step_after_step_resume_breakpoint = 0; 1072 ecs->handling_longjmp = 0; /* FIXME */ 1073 ecs->stepping_through_solib_after_catch = 0; 1074 ecs->stepping_through_solib_catchpoints = NULL; 1075 ecs->enable_hw_watchpoints_after_wait = 0; 1076 ecs->sal = find_pc_line (prev_pc, 0); 1077 ecs->current_line = ecs->sal.line; 1078 ecs->current_symtab = ecs->sal.symtab; 1079 ecs->infwait_state = infwait_normal_state; 1080 ecs->waiton_ptid = pid_to_ptid (-1); 1081 ecs->wp = &(ecs->ws); 1082} 1083 1084/* Return the cached copy of the last pid/waitstatus returned by 1085 target_wait()/deprecated_target_wait_hook(). The data is actually 1086 cached by handle_inferior_event(), which gets called immediately 1087 after target_wait()/deprecated_target_wait_hook(). */ 1088 1089void 1090get_last_target_status (ptid_t *ptidp, struct target_waitstatus *status) 1091{ 1092 *ptidp = target_last_wait_ptid; 1093 *status = target_last_waitstatus; 1094} 1095 1096/* Switch thread contexts, maintaining "infrun state". */ 1097 1098static void 1099context_switch (struct execution_control_state *ecs) 1100{ 1101 /* Caution: it may happen that the new thread (or the old one!) 1102 is not in the thread list. In this case we must not attempt 1103 to "switch context", or we run the risk that our context may 1104 be lost. This may happen as a result of the target module 1105 mishandling thread creation. */ 1106 1107 if (in_thread_list (inferior_ptid) && in_thread_list (ecs->ptid)) 1108 { /* Perform infrun state context switch: */ 1109 /* Save infrun state for the old thread. */ 1110 save_infrun_state (inferior_ptid, prev_pc, 1111 trap_expected, step_resume_breakpoint, 1112 step_range_start, 1113 step_range_end, &step_frame_id, 1114 ecs->handling_longjmp, ecs->another_trap, 1115 ecs->stepping_through_solib_after_catch, 1116 ecs->stepping_through_solib_catchpoints, 1117 ecs->current_line, ecs->current_symtab); 1118 1119 /* Load infrun state for the new thread. */ 1120 load_infrun_state (ecs->ptid, &prev_pc, 1121 &trap_expected, &step_resume_breakpoint, 1122 &step_range_start, 1123 &step_range_end, &step_frame_id, 1124 &ecs->handling_longjmp, &ecs->another_trap, 1125 &ecs->stepping_through_solib_after_catch, 1126 &ecs->stepping_through_solib_catchpoints, 1127 &ecs->current_line, &ecs->current_symtab); 1128 } 1129 inferior_ptid = ecs->ptid; 1130} 1131 1132static void 1133adjust_pc_after_break (struct execution_control_state *ecs) 1134{ 1135 CORE_ADDR breakpoint_pc; 1136 1137 /* If this target does not decrement the PC after breakpoints, then 1138 we have nothing to do. */ 1139 if (DECR_PC_AFTER_BREAK == 0) 1140 return; 1141 1142 /* If we've hit a breakpoint, we'll normally be stopped with SIGTRAP. If 1143 we aren't, just return. 1144 1145 We assume that waitkinds other than TARGET_WAITKIND_STOPPED are not 1146 affected by DECR_PC_AFTER_BREAK. Other waitkinds which are implemented 1147 by software breakpoints should be handled through the normal breakpoint 1148 layer. 1149 1150 NOTE drow/2004-01-31: On some targets, breakpoints may generate 1151 different signals (SIGILL or SIGEMT for instance), but it is less 1152 clear where the PC is pointing afterwards. It may not match 1153 DECR_PC_AFTER_BREAK. I don't know any specific target that generates 1154 these signals at breakpoints (the code has been in GDB since at least 1155 1992) so I can not guess how to handle them here. 1156 1157 In earlier versions of GDB, a target with HAVE_NONSTEPPABLE_WATCHPOINTS 1158 would have the PC after hitting a watchpoint affected by 1159 DECR_PC_AFTER_BREAK. I haven't found any target with both of these set 1160 in GDB history, and it seems unlikely to be correct, so 1161 HAVE_NONSTEPPABLE_WATCHPOINTS is not checked here. */ 1162 1163 if (ecs->ws.kind != TARGET_WAITKIND_STOPPED) 1164 return; 1165 1166 if (ecs->ws.value.sig != TARGET_SIGNAL_TRAP) 1167 return; 1168 1169 /* Find the location where (if we've hit a breakpoint) the 1170 breakpoint would be. */ 1171 breakpoint_pc = read_pc_pid (ecs->ptid) - DECR_PC_AFTER_BREAK; 1172 1173 if (SOFTWARE_SINGLE_STEP_P ()) 1174 { 1175 /* When using software single-step, a SIGTRAP can only indicate 1176 an inserted breakpoint. This actually makes things 1177 easier. */ 1178 if (singlestep_breakpoints_inserted_p) 1179 /* When software single stepping, the instruction at [prev_pc] 1180 is never a breakpoint, but the instruction following 1181 [prev_pc] (in program execution order) always is. Assume 1182 that following instruction was reached and hence a software 1183 breakpoint was hit. */ 1184 write_pc_pid (breakpoint_pc, ecs->ptid); 1185 else if (software_breakpoint_inserted_here_p (breakpoint_pc)) 1186 /* The inferior was free running (i.e., no single-step 1187 breakpoints inserted) and it hit a software breakpoint. */ 1188 write_pc_pid (breakpoint_pc, ecs->ptid); 1189 } 1190 else 1191 { 1192 /* When using hardware single-step, a SIGTRAP is reported for 1193 both a completed single-step and a software breakpoint. Need 1194 to differentiate between the two as the latter needs 1195 adjusting but the former does not. */ 1196 if (currently_stepping (ecs)) 1197 { 1198 if (prev_pc == breakpoint_pc 1199 && software_breakpoint_inserted_here_p (breakpoint_pc)) 1200 /* Hardware single-stepped a software breakpoint (as 1201 occures when the inferior is resumed with PC pointing 1202 at not-yet-hit software breakpoint). Since the 1203 breakpoint really is executed, the inferior needs to be 1204 backed up to the breakpoint address. */ 1205 write_pc_pid (breakpoint_pc, ecs->ptid); 1206 } 1207 else 1208 { 1209 if (software_breakpoint_inserted_here_p (breakpoint_pc)) 1210 /* The inferior was free running (i.e., no hardware 1211 single-step and no possibility of a false SIGTRAP) and 1212 hit a software breakpoint. */ 1213 write_pc_pid (breakpoint_pc, ecs->ptid); 1214 } 1215 } 1216} 1217 1218/* Given an execution control state that has been freshly filled in 1219 by an event from the inferior, figure out what it means and take 1220 appropriate action. */ 1221 1222int stepped_after_stopped_by_watchpoint; 1223 1224void 1225handle_inferior_event (struct execution_control_state *ecs) 1226{ 1227 /* NOTE: cagney/2003-03-28: If you're looking at this code and 1228 thinking that the variable stepped_after_stopped_by_watchpoint 1229 isn't used, then you're wrong! The macro STOPPED_BY_WATCHPOINT, 1230 defined in the file "config/pa/nm-hppah.h", accesses the variable 1231 indirectly. Mutter something rude about the HP merge. */ 1232 int sw_single_step_trap_p = 0; 1233 int stopped_by_watchpoint = -1; /* Mark as unknown. */ 1234 1235 /* Cache the last pid/waitstatus. */ 1236 target_last_wait_ptid = ecs->ptid; 1237 target_last_waitstatus = *ecs->wp; 1238 1239 adjust_pc_after_break (ecs); 1240 1241 switch (ecs->infwait_state) 1242 { 1243 case infwait_thread_hop_state: 1244 /* Cancel the waiton_ptid. */ 1245 ecs->waiton_ptid = pid_to_ptid (-1); 1246 /* See comments where a TARGET_WAITKIND_SYSCALL_RETURN event 1247 is serviced in this loop, below. */ 1248 if (ecs->enable_hw_watchpoints_after_wait) 1249 { 1250 TARGET_ENABLE_HW_WATCHPOINTS (PIDGET (inferior_ptid)); 1251 ecs->enable_hw_watchpoints_after_wait = 0; 1252 } 1253 stepped_after_stopped_by_watchpoint = 0; 1254 break; 1255 1256 case infwait_normal_state: 1257 /* See comments where a TARGET_WAITKIND_SYSCALL_RETURN event 1258 is serviced in this loop, below. */ 1259 if (ecs->enable_hw_watchpoints_after_wait) 1260 { 1261 TARGET_ENABLE_HW_WATCHPOINTS (PIDGET (inferior_ptid)); 1262 ecs->enable_hw_watchpoints_after_wait = 0; 1263 } 1264 stepped_after_stopped_by_watchpoint = 0; 1265 break; 1266 1267 case infwait_nullified_state: 1268 stepped_after_stopped_by_watchpoint = 0; 1269 break; 1270 1271 case infwait_nonstep_watch_state: 1272 insert_breakpoints (); 1273 1274 /* FIXME-maybe: is this cleaner than setting a flag? Does it 1275 handle things like signals arriving and other things happening 1276 in combination correctly? */ 1277 stepped_after_stopped_by_watchpoint = 1; 1278 break; 1279 1280 default: 1281 internal_error (__FILE__, __LINE__, "bad switch"); 1282 } 1283 ecs->infwait_state = infwait_normal_state; 1284 1285 flush_cached_frames (); 1286 1287 /* If it's a new process, add it to the thread database */ 1288 1289 ecs->new_thread_event = (!ptid_equal (ecs->ptid, inferior_ptid) 1290 && !ptid_equal (ecs->ptid, minus_one_ptid) 1291 && !in_thread_list (ecs->ptid)); 1292 1293 if (ecs->ws.kind != TARGET_WAITKIND_EXITED 1294 && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED && ecs->new_thread_event) 1295 { 1296 add_thread (ecs->ptid); 1297 1298 ui_out_text (uiout, "[New "); 1299 ui_out_text (uiout, target_pid_or_tid_to_str (ecs->ptid)); 1300 ui_out_text (uiout, "]\n"); 1301 } 1302 1303 switch (ecs->ws.kind) 1304 { 1305 case TARGET_WAITKIND_LOADED: 1306 /* Ignore gracefully during startup of the inferior, as it 1307 might be the shell which has just loaded some objects, 1308 otherwise add the symbols for the newly loaded objects. */ 1309#ifdef SOLIB_ADD 1310 if (stop_soon == NO_STOP_QUIETLY) 1311 { 1312 /* Remove breakpoints, SOLIB_ADD might adjust 1313 breakpoint addresses via breakpoint_re_set. */ 1314 if (breakpoints_inserted) 1315 remove_breakpoints (); 1316 1317 /* Check for any newly added shared libraries if we're 1318 supposed to be adding them automatically. Switch 1319 terminal for any messages produced by 1320 breakpoint_re_set. */ 1321 target_terminal_ours_for_output (); 1322 /* NOTE: cagney/2003-11-25: Make certain that the target 1323 stack's section table is kept up-to-date. Architectures, 1324 (e.g., PPC64), use the section table to perform 1325 operations such as address => section name and hence 1326 require the table to contain all sections (including 1327 those found in shared libraries). */ 1328 /* NOTE: cagney/2003-11-25: Pass current_target and not 1329 exec_ops to SOLIB_ADD. This is because current GDB is 1330 only tooled to propagate section_table changes out from 1331 the "current_target" (see target_resize_to_sections), and 1332 not up from the exec stratum. This, of course, isn't 1333 right. "infrun.c" should only interact with the 1334 exec/process stratum, instead relying on the target stack 1335 to propagate relevant changes (stop, section table 1336 changed, ...) up to other layers. */ 1337 SOLIB_ADD (NULL, 0, ¤t_target, auto_solib_add); 1338 target_terminal_inferior (); 1339 1340 /* Reinsert breakpoints and continue. */ 1341 if (breakpoints_inserted) 1342 insert_breakpoints (); 1343 } 1344#endif 1345 resume (0, TARGET_SIGNAL_0); 1346 prepare_to_wait (ecs); 1347 return; 1348 1349 case TARGET_WAITKIND_SPURIOUS: 1350 resume (0, TARGET_SIGNAL_0); 1351 prepare_to_wait (ecs); 1352 return; 1353 1354 case TARGET_WAITKIND_EXITED: 1355 target_terminal_ours (); /* Must do this before mourn anyway */ 1356 print_stop_reason (EXITED, ecs->ws.value.integer); 1357 1358 /* Record the exit code in the convenience variable $_exitcode, so 1359 that the user can inspect this again later. */ 1360 set_internalvar (lookup_internalvar ("_exitcode"), 1361 value_from_longest (builtin_type_int, 1362 (LONGEST) ecs->ws.value.integer)); 1363 gdb_flush (gdb_stdout); 1364 target_mourn_inferior (); 1365 singlestep_breakpoints_inserted_p = 0; /*SOFTWARE_SINGLE_STEP_P() */ 1366 stop_print_frame = 0; 1367 stop_stepping (ecs); 1368 return; 1369 1370 case TARGET_WAITKIND_SIGNALLED: 1371 stop_print_frame = 0; 1372 stop_signal = ecs->ws.value.sig; 1373 target_terminal_ours (); /* Must do this before mourn anyway */ 1374 1375 /* Note: By definition of TARGET_WAITKIND_SIGNALLED, we shouldn't 1376 reach here unless the inferior is dead. However, for years 1377 target_kill() was called here, which hints that fatal signals aren't 1378 really fatal on some systems. If that's true, then some changes 1379 may be needed. */ 1380 target_mourn_inferior (); 1381 1382 print_stop_reason (SIGNAL_EXITED, stop_signal); 1383 singlestep_breakpoints_inserted_p = 0; /*SOFTWARE_SINGLE_STEP_P() */ 1384 stop_stepping (ecs); 1385 return; 1386 1387 /* The following are the only cases in which we keep going; 1388 the above cases end in a continue or goto. */ 1389 case TARGET_WAITKIND_FORKED: 1390 case TARGET_WAITKIND_VFORKED: 1391 stop_signal = TARGET_SIGNAL_TRAP; 1392 pending_follow.kind = ecs->ws.kind; 1393 1394 pending_follow.fork_event.parent_pid = PIDGET (ecs->ptid); 1395 pending_follow.fork_event.child_pid = ecs->ws.value.related_pid; 1396 1397 stop_pc = read_pc (); 1398 1399 stop_bpstat = bpstat_stop_status (stop_pc, ecs->ptid, 0); 1400 1401 ecs->random_signal = !bpstat_explains_signal (stop_bpstat); 1402 1403 /* If no catchpoint triggered for this, then keep going. */ 1404 if (ecs->random_signal) 1405 { 1406 stop_signal = TARGET_SIGNAL_0; 1407 keep_going (ecs); 1408 return; 1409 } 1410 goto process_event_stop_test; 1411 1412 case TARGET_WAITKIND_EXECD: 1413 stop_signal = TARGET_SIGNAL_TRAP; 1414 1415 /* NOTE drow/2002-12-05: This code should be pushed down into the 1416 target_wait function. Until then following vfork on HP/UX 10.20 1417 is probably broken by this. Of course, it's broken anyway. */ 1418 /* Is this a target which reports multiple exec events per actual 1419 call to exec()? (HP-UX using ptrace does, for example.) If so, 1420 ignore all but the last one. Just resume the exec'r, and wait 1421 for the next exec event. */ 1422 if (inferior_ignoring_leading_exec_events) 1423 { 1424 inferior_ignoring_leading_exec_events--; 1425 if (pending_follow.kind == TARGET_WAITKIND_VFORKED) 1426 ENSURE_VFORKING_PARENT_REMAINS_STOPPED (pending_follow.fork_event. 1427 parent_pid); 1428 target_resume (ecs->ptid, 0, TARGET_SIGNAL_0); 1429 prepare_to_wait (ecs); 1430 return; 1431 } 1432 inferior_ignoring_leading_exec_events = 1433 target_reported_exec_events_per_exec_call () - 1; 1434 1435 pending_follow.execd_pathname = 1436 savestring (ecs->ws.value.execd_pathname, 1437 strlen (ecs->ws.value.execd_pathname)); 1438 1439 /* This causes the eventpoints and symbol table to be reset. Must 1440 do this now, before trying to determine whether to stop. */ 1441 follow_exec (PIDGET (inferior_ptid), pending_follow.execd_pathname); 1442 xfree (pending_follow.execd_pathname); 1443 1444 stop_pc = read_pc_pid (ecs->ptid); 1445 ecs->saved_inferior_ptid = inferior_ptid; 1446 inferior_ptid = ecs->ptid; 1447 1448 stop_bpstat = bpstat_stop_status (stop_pc, ecs->ptid, 0); 1449 1450 ecs->random_signal = !bpstat_explains_signal (stop_bpstat); 1451 inferior_ptid = ecs->saved_inferior_ptid; 1452 1453 /* If no catchpoint triggered for this, then keep going. */ 1454 if (ecs->random_signal) 1455 { 1456 stop_signal = TARGET_SIGNAL_0; 1457 keep_going (ecs); 1458 return; 1459 } 1460 goto process_event_stop_test; 1461 1462 /* These syscall events are returned on HP-UX, as part of its 1463 implementation of page-protection-based "hardware" watchpoints. 1464 HP-UX has unfortunate interactions between page-protections and 1465 some system calls. Our solution is to disable hardware watches 1466 when a system call is entered, and reenable them when the syscall 1467 completes. The downside of this is that we may miss the precise 1468 point at which a watched piece of memory is modified. "Oh well." 1469 1470 Note that we may have multiple threads running, which may each 1471 enter syscalls at roughly the same time. Since we don't have a 1472 good notion currently of whether a watched piece of memory is 1473 thread-private, we'd best not have any page-protections active 1474 when any thread is in a syscall. Thus, we only want to reenable 1475 hardware watches when no threads are in a syscall. 1476 1477 Also, be careful not to try to gather much state about a thread 1478 that's in a syscall. It's frequently a losing proposition. */ 1479 case TARGET_WAITKIND_SYSCALL_ENTRY: 1480 number_of_threads_in_syscalls++; 1481 if (number_of_threads_in_syscalls == 1) 1482 { 1483 TARGET_DISABLE_HW_WATCHPOINTS (PIDGET (inferior_ptid)); 1484 } 1485 resume (0, TARGET_SIGNAL_0); 1486 prepare_to_wait (ecs); 1487 return; 1488 1489 /* Before examining the threads further, step this thread to 1490 get it entirely out of the syscall. (We get notice of the 1491 event when the thread is just on the verge of exiting a 1492 syscall. Stepping one instruction seems to get it back 1493 into user code.) 1494 1495 Note that although the logical place to reenable h/w watches 1496 is here, we cannot. We cannot reenable them before stepping 1497 the thread (this causes the next wait on the thread to hang). 1498 1499 Nor can we enable them after stepping until we've done a wait. 1500 Thus, we simply set the flag ecs->enable_hw_watchpoints_after_wait 1501 here, which will be serviced immediately after the target 1502 is waited on. */ 1503 case TARGET_WAITKIND_SYSCALL_RETURN: 1504 target_resume (ecs->ptid, 1, TARGET_SIGNAL_0); 1505 1506 if (number_of_threads_in_syscalls > 0) 1507 { 1508 number_of_threads_in_syscalls--; 1509 ecs->enable_hw_watchpoints_after_wait = 1510 (number_of_threads_in_syscalls == 0); 1511 } 1512 prepare_to_wait (ecs); 1513 return; 1514 1515 case TARGET_WAITKIND_STOPPED: 1516 stop_signal = ecs->ws.value.sig; 1517 break; 1518 1519 /* We had an event in the inferior, but we are not interested 1520 in handling it at this level. The lower layers have already 1521 done what needs to be done, if anything. 1522 1523 One of the possible circumstances for this is when the 1524 inferior produces output for the console. The inferior has 1525 not stopped, and we are ignoring the event. Another possible 1526 circumstance is any event which the lower level knows will be 1527 reported multiple times without an intervening resume. */ 1528 case TARGET_WAITKIND_IGNORE: 1529 prepare_to_wait (ecs); 1530 return; 1531 } 1532 1533 /* We may want to consider not doing a resume here in order to give 1534 the user a chance to play with the new thread. It might be good 1535 to make that a user-settable option. */ 1536 1537 /* At this point, all threads are stopped (happens automatically in 1538 either the OS or the native code). Therefore we need to continue 1539 all threads in order to make progress. */ 1540 if (ecs->new_thread_event) 1541 { 1542 target_resume (RESUME_ALL, 0, TARGET_SIGNAL_0); 1543 prepare_to_wait (ecs); 1544 return; 1545 } 1546 1547 stop_pc = read_pc_pid (ecs->ptid); 1548 1549 if (stepping_past_singlestep_breakpoint) 1550 { 1551 gdb_assert (SOFTWARE_SINGLE_STEP_P () 1552 && singlestep_breakpoints_inserted_p); 1553 gdb_assert (ptid_equal (singlestep_ptid, ecs->ptid)); 1554 gdb_assert (!ptid_equal (singlestep_ptid, saved_singlestep_ptid)); 1555 1556 stepping_past_singlestep_breakpoint = 0; 1557 1558 /* We've either finished single-stepping past the single-step 1559 breakpoint, or stopped for some other reason. It would be nice if 1560 we could tell, but we can't reliably. */ 1561 if (stop_signal == TARGET_SIGNAL_TRAP) 1562 { 1563 /* Pull the single step breakpoints out of the target. */ 1564 SOFTWARE_SINGLE_STEP (0, 0); 1565 singlestep_breakpoints_inserted_p = 0; 1566 1567 ecs->random_signal = 0; 1568 1569 ecs->ptid = saved_singlestep_ptid; 1570 context_switch (ecs); 1571 if (deprecated_context_hook) 1572 deprecated_context_hook (pid_to_thread_id (ecs->ptid)); 1573 1574 resume (1, TARGET_SIGNAL_0); 1575 prepare_to_wait (ecs); 1576 return; 1577 } 1578 } 1579 1580 stepping_past_singlestep_breakpoint = 0; 1581 1582 /* See if a thread hit a thread-specific breakpoint that was meant for 1583 another thread. If so, then step that thread past the breakpoint, 1584 and continue it. */ 1585 1586 if (stop_signal == TARGET_SIGNAL_TRAP) 1587 { 1588 int thread_hop_needed = 0; 1589 1590 /* Check if a regular breakpoint has been hit before checking 1591 for a potential single step breakpoint. Otherwise, GDB will 1592 not see this breakpoint hit when stepping onto breakpoints. */ 1593 if (breakpoints_inserted && breakpoint_here_p (stop_pc)) 1594 { 1595 ecs->random_signal = 0; 1596 if (!breakpoint_thread_match (stop_pc, ecs->ptid)) 1597 thread_hop_needed = 1; 1598 } 1599 else if (SOFTWARE_SINGLE_STEP_P () && singlestep_breakpoints_inserted_p) 1600 { 1601 ecs->random_signal = 0; 1602 /* The call to in_thread_list is necessary because PTIDs sometimes 1603 change when we go from single-threaded to multi-threaded. If 1604 the singlestep_ptid is still in the list, assume that it is 1605 really different from ecs->ptid. */ 1606 if (!ptid_equal (singlestep_ptid, ecs->ptid) 1607 && in_thread_list (singlestep_ptid)) 1608 { 1609 thread_hop_needed = 1; 1610 stepping_past_singlestep_breakpoint = 1; 1611 saved_singlestep_ptid = singlestep_ptid; 1612 } 1613 } 1614 1615 if (thread_hop_needed) 1616 { 1617 int remove_status; 1618 1619 /* Saw a breakpoint, but it was hit by the wrong thread. 1620 Just continue. */ 1621 1622 if (SOFTWARE_SINGLE_STEP_P () && singlestep_breakpoints_inserted_p) 1623 { 1624 /* Pull the single step breakpoints out of the target. */ 1625 SOFTWARE_SINGLE_STEP (0, 0); 1626 singlestep_breakpoints_inserted_p = 0; 1627 } 1628 1629 remove_status = remove_breakpoints (); 1630 /* Did we fail to remove breakpoints? If so, try 1631 to set the PC past the bp. (There's at least 1632 one situation in which we can fail to remove 1633 the bp's: On HP-UX's that use ttrace, we can't 1634 change the address space of a vforking child 1635 process until the child exits (well, okay, not 1636 then either :-) or execs. */ 1637 if (remove_status != 0) 1638 { 1639 /* FIXME! This is obviously non-portable! */ 1640 write_pc_pid (stop_pc + 4, ecs->ptid); 1641 /* We need to restart all the threads now, 1642 * unles we're running in scheduler-locked mode. 1643 * Use currently_stepping to determine whether to 1644 * step or continue. 1645 */ 1646 /* FIXME MVS: is there any reason not to call resume()? */ 1647 if (scheduler_mode == schedlock_on) 1648 target_resume (ecs->ptid, 1649 currently_stepping (ecs), TARGET_SIGNAL_0); 1650 else 1651 target_resume (RESUME_ALL, 1652 currently_stepping (ecs), TARGET_SIGNAL_0); 1653 prepare_to_wait (ecs); 1654 return; 1655 } 1656 else 1657 { /* Single step */ 1658 breakpoints_inserted = 0; 1659 if (!ptid_equal (inferior_ptid, ecs->ptid)) 1660 context_switch (ecs); 1661 ecs->waiton_ptid = ecs->ptid; 1662 ecs->wp = &(ecs->ws); 1663 ecs->another_trap = 1; 1664 1665 ecs->infwait_state = infwait_thread_hop_state; 1666 keep_going (ecs); 1667 registers_changed (); 1668 return; 1669 } 1670 } 1671 else if (SOFTWARE_SINGLE_STEP_P () && singlestep_breakpoints_inserted_p) 1672 { 1673 sw_single_step_trap_p = 1; 1674 ecs->random_signal = 0; 1675 } 1676 } 1677 else 1678 ecs->random_signal = 1; 1679 1680 /* See if something interesting happened to the non-current thread. If 1681 so, then switch to that thread. */ 1682 if (!ptid_equal (ecs->ptid, inferior_ptid)) 1683 { 1684 context_switch (ecs); 1685 1686 if (deprecated_context_hook) 1687 deprecated_context_hook (pid_to_thread_id (ecs->ptid)); 1688 1689 flush_cached_frames (); 1690 } 1691 1692 if (SOFTWARE_SINGLE_STEP_P () && singlestep_breakpoints_inserted_p) 1693 { 1694 /* Pull the single step breakpoints out of the target. */ 1695 SOFTWARE_SINGLE_STEP (0, 0); 1696 singlestep_breakpoints_inserted_p = 0; 1697 } 1698 1699 /* If PC is pointing at a nullified instruction, then step beyond 1700 it so that the user won't be confused when GDB appears to be ready 1701 to execute it. */ 1702 1703 /* if (INSTRUCTION_NULLIFIED && currently_stepping (ecs)) */ 1704 if (INSTRUCTION_NULLIFIED) 1705 { 1706 registers_changed (); 1707 target_resume (ecs->ptid, 1, TARGET_SIGNAL_0); 1708 1709 /* We may have received a signal that we want to pass to 1710 the inferior; therefore, we must not clobber the waitstatus 1711 in WS. */ 1712 1713 ecs->infwait_state = infwait_nullified_state; 1714 ecs->waiton_ptid = ecs->ptid; 1715 ecs->wp = &(ecs->tmpstatus); 1716 prepare_to_wait (ecs); 1717 return; 1718 } 1719 1720 /* It may not be necessary to disable the watchpoint to stop over 1721 it. For example, the PA can (with some kernel cooperation) 1722 single step over a watchpoint without disabling the watchpoint. */ 1723 if (HAVE_STEPPABLE_WATCHPOINT && STOPPED_BY_WATCHPOINT (ecs->ws)) 1724 { 1725 resume (1, 0); 1726 prepare_to_wait (ecs); 1727 return; 1728 } 1729 1730 /* It is far more common to need to disable a watchpoint to step 1731 the inferior over it. FIXME. What else might a debug 1732 register or page protection watchpoint scheme need here? */ 1733 if (HAVE_NONSTEPPABLE_WATCHPOINT && STOPPED_BY_WATCHPOINT (ecs->ws)) 1734 { 1735 /* At this point, we are stopped at an instruction which has 1736 attempted to write to a piece of memory under control of 1737 a watchpoint. The instruction hasn't actually executed 1738 yet. If we were to evaluate the watchpoint expression 1739 now, we would get the old value, and therefore no change 1740 would seem to have occurred. 1741 1742 In order to make watchpoints work `right', we really need 1743 to complete the memory write, and then evaluate the 1744 watchpoint expression. The following code does that by 1745 removing the watchpoint (actually, all watchpoints and 1746 breakpoints), single-stepping the target, re-inserting 1747 watchpoints, and then falling through to let normal 1748 single-step processing handle proceed. Since this 1749 includes evaluating watchpoints, things will come to a 1750 stop in the correct manner. */ 1751 1752 remove_breakpoints (); 1753 registers_changed (); 1754 target_resume (ecs->ptid, 1, TARGET_SIGNAL_0); /* Single step */ 1755 1756 ecs->waiton_ptid = ecs->ptid; 1757 ecs->wp = &(ecs->ws); 1758 ecs->infwait_state = infwait_nonstep_watch_state; 1759 prepare_to_wait (ecs); 1760 return; 1761 } 1762 1763 /* It may be possible to simply continue after a watchpoint. */ 1764 if (HAVE_CONTINUABLE_WATCHPOINT) 1765 stopped_by_watchpoint = STOPPED_BY_WATCHPOINT (ecs->ws); 1766 1767 ecs->stop_func_start = 0; 1768 ecs->stop_func_end = 0; 1769 ecs->stop_func_name = 0; 1770 /* Don't care about return value; stop_func_start and stop_func_name 1771 will both be 0 if it doesn't work. */ 1772 find_pc_partial_function (stop_pc, &ecs->stop_func_name, 1773 &ecs->stop_func_start, &ecs->stop_func_end); 1774 ecs->stop_func_start += DEPRECATED_FUNCTION_START_OFFSET; 1775 ecs->another_trap = 0; 1776 bpstat_clear (&stop_bpstat); 1777 stop_step = 0; 1778 stop_stack_dummy = 0; 1779 stop_print_frame = 1; 1780 ecs->random_signal = 0; 1781 stopped_by_random_signal = 0; 1782 breakpoints_failed = 0; 1783 1784 /* Look at the cause of the stop, and decide what to do. 1785 The alternatives are: 1786 1) break; to really stop and return to the debugger, 1787 2) drop through to start up again 1788 (set ecs->another_trap to 1 to single step once) 1789 3) set ecs->random_signal to 1, and the decision between 1 and 2 1790 will be made according to the signal handling tables. */ 1791 1792 /* First, distinguish signals caused by the debugger from signals 1793 that have to do with the program's own actions. Note that 1794 breakpoint insns may cause SIGTRAP or SIGILL or SIGEMT, depending 1795 on the operating system version. Here we detect when a SIGILL or 1796 SIGEMT is really a breakpoint and change it to SIGTRAP. We do 1797 something similar for SIGSEGV, since a SIGSEGV will be generated 1798 when we're trying to execute a breakpoint instruction on a 1799 non-executable stack. This happens for call dummy breakpoints 1800 for architectures like SPARC that place call dummies on the 1801 stack. */ 1802 1803 if (stop_signal == TARGET_SIGNAL_TRAP 1804 || (breakpoints_inserted 1805 && (stop_signal == TARGET_SIGNAL_ILL 1806 || stop_signal == TARGET_SIGNAL_SEGV 1807 || stop_signal == TARGET_SIGNAL_EMT)) 1808 || stop_soon == STOP_QUIETLY || stop_soon == STOP_QUIETLY_NO_SIGSTOP) 1809 { 1810 if (stop_signal == TARGET_SIGNAL_TRAP && stop_after_trap) 1811 { 1812 stop_print_frame = 0; 1813 stop_stepping (ecs); 1814 return; 1815 } 1816 1817 /* This is originated from start_remote(), start_inferior() and 1818 shared libraries hook functions. */ 1819 if (stop_soon == STOP_QUIETLY) 1820 { 1821 stop_stepping (ecs); 1822 return; 1823 } 1824 1825 /* This originates from attach_command(). We need to overwrite 1826 the stop_signal here, because some kernels don't ignore a 1827 SIGSTOP in a subsequent ptrace(PTRACE_SONT,SOGSTOP) call. 1828 See more comments in inferior.h. */ 1829 if (stop_soon == STOP_QUIETLY_NO_SIGSTOP) 1830 { 1831 stop_stepping (ecs); 1832 if (stop_signal == TARGET_SIGNAL_STOP) 1833 stop_signal = TARGET_SIGNAL_0; 1834 return; 1835 } 1836 1837 /* Don't even think about breakpoints if just proceeded over a 1838 breakpoint. */ 1839 if (stop_signal == TARGET_SIGNAL_TRAP && trap_expected) 1840 bpstat_clear (&stop_bpstat); 1841 else 1842 { 1843 /* See if there is a breakpoint at the current PC. */ 1844 stop_bpstat = bpstat_stop_status (stop_pc, ecs->ptid, 1845 stopped_by_watchpoint); 1846 1847 /* Following in case break condition called a 1848 function. */ 1849 stop_print_frame = 1; 1850 } 1851 1852 /* NOTE: cagney/2003-03-29: These two checks for a random signal 1853 at one stage in the past included checks for an inferior 1854 function call's call dummy's return breakpoint. The original 1855 comment, that went with the test, read: 1856 1857 ``End of a stack dummy. Some systems (e.g. Sony news) give 1858 another signal besides SIGTRAP, so check here as well as 1859 above.'' 1860 1861 If someone ever tries to get get call dummys on a 1862 non-executable stack to work (where the target would stop 1863 with something like a SIGSEGV), then those tests might need 1864 to be re-instated. Given, however, that the tests were only 1865 enabled when momentary breakpoints were not being used, I 1866 suspect that it won't be the case. 1867 1868 NOTE: kettenis/2004-02-05: Indeed such checks don't seem to 1869 be necessary for call dummies on a non-executable stack on 1870 SPARC. */ 1871 1872 if (stop_signal == TARGET_SIGNAL_TRAP) 1873 ecs->random_signal 1874 = !(bpstat_explains_signal (stop_bpstat) 1875 || trap_expected 1876 || (step_range_end && step_resume_breakpoint == NULL)); 1877 else 1878 { 1879 ecs->random_signal = !bpstat_explains_signal (stop_bpstat); 1880 if (!ecs->random_signal) 1881 stop_signal = TARGET_SIGNAL_TRAP; 1882 } 1883 } 1884 1885 /* When we reach this point, we've pretty much decided 1886 that the reason for stopping must've been a random 1887 (unexpected) signal. */ 1888 1889 else 1890 ecs->random_signal = 1; 1891 1892process_event_stop_test: 1893 /* For the program's own signals, act according to 1894 the signal handling tables. */ 1895 1896 if (ecs->random_signal) 1897 { 1898 /* Signal not for debugging purposes. */ 1899 int printed = 0; 1900 1901 stopped_by_random_signal = 1; 1902 1903 if (signal_print[stop_signal]) 1904 { 1905 printed = 1; 1906 target_terminal_ours_for_output (); 1907 print_stop_reason (SIGNAL_RECEIVED, stop_signal); 1908 } 1909 if (signal_stop[stop_signal]) 1910 { 1911 stop_stepping (ecs); 1912 return; 1913 } 1914 /* If not going to stop, give terminal back 1915 if we took it away. */ 1916 else if (printed) 1917 target_terminal_inferior (); 1918 1919 /* Clear the signal if it should not be passed. */ 1920 if (signal_program[stop_signal] == 0) 1921 stop_signal = TARGET_SIGNAL_0; 1922 1923 if (prev_pc == read_pc () 1924 && !breakpoints_inserted 1925 && breakpoint_here_p (read_pc ()) 1926 && step_resume_breakpoint == NULL) 1927 { 1928 /* We were just starting a new sequence, attempting to 1929 single-step off of a breakpoint and expecting a SIGTRAP. 1930 Intead this signal arrives. This signal will take us out 1931 of the stepping range so GDB needs to remember to, when 1932 the signal handler returns, resume stepping off that 1933 breakpoint. */ 1934 /* To simplify things, "continue" is forced to use the same 1935 code paths as single-step - set a breakpoint at the 1936 signal return address and then, once hit, step off that 1937 breakpoint. */ 1938 insert_step_resume_breakpoint_at_frame (get_current_frame ()); 1939 ecs->step_after_step_resume_breakpoint = 1; 1940 } 1941 else if (step_range_end != 0 1942 && stop_signal != TARGET_SIGNAL_0 1943 && stop_pc >= step_range_start && stop_pc < step_range_end 1944 && frame_id_eq (get_frame_id (get_current_frame ()), 1945 step_frame_id)) 1946 { 1947 /* The inferior is about to take a signal that will take it 1948 out of the single step range. Set a breakpoint at the 1949 current PC (which is presumably where the signal handler 1950 will eventually return) and then allow the inferior to 1951 run free. 1952 1953 Note that this is only needed for a signal delivered 1954 while in the single-step range. Nested signals aren't a 1955 problem as they eventually all return. */ 1956 insert_step_resume_breakpoint_at_frame (get_current_frame ()); 1957 } 1958 keep_going (ecs); 1959 return; 1960 } 1961 1962 /* Handle cases caused by hitting a breakpoint. */ 1963 { 1964 CORE_ADDR jmp_buf_pc; 1965 struct bpstat_what what; 1966 1967 what = bpstat_what (stop_bpstat); 1968 1969 if (what.call_dummy) 1970 { 1971 stop_stack_dummy = 1; 1972 } 1973 1974 switch (what.main_action) 1975 { 1976 case BPSTAT_WHAT_SET_LONGJMP_RESUME: 1977 /* If we hit the breakpoint at longjmp, disable it for the 1978 duration of this command. Then, install a temporary 1979 breakpoint at the target of the jmp_buf. */ 1980 disable_longjmp_breakpoint (); 1981 remove_breakpoints (); 1982 breakpoints_inserted = 0; 1983 if (!GET_LONGJMP_TARGET_P () || !GET_LONGJMP_TARGET (&jmp_buf_pc)) 1984 { 1985 keep_going (ecs); 1986 return; 1987 } 1988 1989 /* Need to blow away step-resume breakpoint, as it 1990 interferes with us */ 1991 if (step_resume_breakpoint != NULL) 1992 { 1993 delete_step_resume_breakpoint (&step_resume_breakpoint); 1994 } 1995 1996 set_longjmp_resume_breakpoint (jmp_buf_pc, null_frame_id); 1997 ecs->handling_longjmp = 1; /* FIXME */ 1998 keep_going (ecs); 1999 return; 2000 2001 case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME: 2002 case BPSTAT_WHAT_CLEAR_LONGJMP_RESUME_SINGLE: 2003 remove_breakpoints (); 2004 breakpoints_inserted = 0; 2005 disable_longjmp_breakpoint (); 2006 ecs->handling_longjmp = 0; /* FIXME */ 2007 if (what.main_action == BPSTAT_WHAT_CLEAR_LONGJMP_RESUME) 2008 break; 2009 /* else fallthrough */ 2010 2011 case BPSTAT_WHAT_SINGLE: 2012 if (breakpoints_inserted) 2013 { 2014 remove_breakpoints (); 2015 } 2016 breakpoints_inserted = 0; 2017 ecs->another_trap = 1; 2018 /* Still need to check other stuff, at least the case 2019 where we are stepping and step out of the right range. */ 2020 break; 2021 2022 case BPSTAT_WHAT_STOP_NOISY: 2023 stop_print_frame = 1; 2024 2025 /* We are about to nuke the step_resume_breakpointt via the 2026 cleanup chain, so no need to worry about it here. */ 2027 2028 stop_stepping (ecs); 2029 return; 2030 2031 case BPSTAT_WHAT_STOP_SILENT: 2032 stop_print_frame = 0; 2033 2034 /* We are about to nuke the step_resume_breakpoin via the 2035 cleanup chain, so no need to worry about it here. */ 2036 2037 stop_stepping (ecs); 2038 return; 2039 2040 case BPSTAT_WHAT_STEP_RESUME: 2041 /* This proably demands a more elegant solution, but, yeah 2042 right... 2043 2044 This function's use of the simple variable 2045 step_resume_breakpoint doesn't seem to accomodate 2046 simultaneously active step-resume bp's, although the 2047 breakpoint list certainly can. 2048 2049 If we reach here and step_resume_breakpoint is already 2050 NULL, then apparently we have multiple active 2051 step-resume bp's. We'll just delete the breakpoint we 2052 stopped at, and carry on. 2053 2054 Correction: what the code currently does is delete a 2055 step-resume bp, but it makes no effort to ensure that 2056 the one deleted is the one currently stopped at. MVS */ 2057 2058 if (step_resume_breakpoint == NULL) 2059 { 2060 step_resume_breakpoint = 2061 bpstat_find_step_resume_breakpoint (stop_bpstat); 2062 } 2063 delete_step_resume_breakpoint (&step_resume_breakpoint); 2064 if (ecs->step_after_step_resume_breakpoint) 2065 { 2066 /* Back when the step-resume breakpoint was inserted, we 2067 were trying to single-step off a breakpoint. Go back 2068 to doing that. */ 2069 ecs->step_after_step_resume_breakpoint = 0; 2070 remove_breakpoints (); 2071 breakpoints_inserted = 0; 2072 ecs->another_trap = 1; 2073 keep_going (ecs); 2074 return; 2075 } 2076 break; 2077 2078 case BPSTAT_WHAT_THROUGH_SIGTRAMP: 2079 /* If were waiting for a trap, hitting the step_resume_break 2080 doesn't count as getting it. */ 2081 if (trap_expected) 2082 ecs->another_trap = 1; 2083 break; 2084 2085 case BPSTAT_WHAT_CHECK_SHLIBS: 2086 case BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK: 2087#ifdef SOLIB_ADD 2088 { 2089 /* Remove breakpoints, we eventually want to step over the 2090 shlib event breakpoint, and SOLIB_ADD might adjust 2091 breakpoint addresses via breakpoint_re_set. */ 2092 if (breakpoints_inserted) 2093 remove_breakpoints (); 2094 breakpoints_inserted = 0; 2095 2096 /* Check for any newly added shared libraries if we're 2097 supposed to be adding them automatically. Switch 2098 terminal for any messages produced by 2099 breakpoint_re_set. */ 2100 target_terminal_ours_for_output (); 2101 /* NOTE: cagney/2003-11-25: Make certain that the target 2102 stack's section table is kept up-to-date. Architectures, 2103 (e.g., PPC64), use the section table to perform 2104 operations such as address => section name and hence 2105 require the table to contain all sections (including 2106 those found in shared libraries). */ 2107 /* NOTE: cagney/2003-11-25: Pass current_target and not 2108 exec_ops to SOLIB_ADD. This is because current GDB is 2109 only tooled to propagate section_table changes out from 2110 the "current_target" (see target_resize_to_sections), and 2111 not up from the exec stratum. This, of course, isn't 2112 right. "infrun.c" should only interact with the 2113 exec/process stratum, instead relying on the target stack 2114 to propagate relevant changes (stop, section table 2115 changed, ...) up to other layers. */ 2116 SOLIB_ADD (NULL, 0, ¤t_target, auto_solib_add); 2117 target_terminal_inferior (); 2118 2119 /* Try to reenable shared library breakpoints, additional 2120 code segments in shared libraries might be mapped in now. */ 2121 re_enable_breakpoints_in_shlibs (); 2122 2123 /* If requested, stop when the dynamic linker notifies 2124 gdb of events. This allows the user to get control 2125 and place breakpoints in initializer routines for 2126 dynamically loaded objects (among other things). */ 2127 if (stop_on_solib_events || stop_stack_dummy) 2128 { 2129 stop_stepping (ecs); 2130 return; 2131 } 2132 2133 /* If we stopped due to an explicit catchpoint, then the 2134 (see above) call to SOLIB_ADD pulled in any symbols 2135 from a newly-loaded library, if appropriate. 2136 2137 We do want the inferior to stop, but not where it is 2138 now, which is in the dynamic linker callback. Rather, 2139 we would like it stop in the user's program, just after 2140 the call that caused this catchpoint to trigger. That 2141 gives the user a more useful vantage from which to 2142 examine their program's state. */ 2143 else if (what.main_action 2144 == BPSTAT_WHAT_CHECK_SHLIBS_RESUME_FROM_HOOK) 2145 { 2146 /* ??rehrauer: If I could figure out how to get the 2147 right return PC from here, we could just set a temp 2148 breakpoint and resume. I'm not sure we can without 2149 cracking open the dld's shared libraries and sniffing 2150 their unwind tables and text/data ranges, and that's 2151 not a terribly portable notion. 2152 2153 Until that time, we must step the inferior out of the 2154 dld callback, and also out of the dld itself (and any 2155 code or stubs in libdld.sl, such as "shl_load" and 2156 friends) until we reach non-dld code. At that point, 2157 we can stop stepping. */ 2158 bpstat_get_triggered_catchpoints (stop_bpstat, 2159 &ecs-> 2160 stepping_through_solib_catchpoints); 2161 ecs->stepping_through_solib_after_catch = 1; 2162 2163 /* Be sure to lift all breakpoints, so the inferior does 2164 actually step past this point... */ 2165 ecs->another_trap = 1; 2166 break; 2167 } 2168 else 2169 { 2170 /* We want to step over this breakpoint, then keep going. */ 2171 ecs->another_trap = 1; 2172 break; 2173 } 2174 } 2175#endif 2176 break; 2177 2178 case BPSTAT_WHAT_LAST: 2179 /* Not a real code, but listed here to shut up gcc -Wall. */ 2180 2181 case BPSTAT_WHAT_KEEP_CHECKING: 2182 break; 2183 } 2184 } 2185 2186 /* We come here if we hit a breakpoint but should not 2187 stop for it. Possibly we also were stepping 2188 and should stop for that. So fall through and 2189 test for stepping. But, if not stepping, 2190 do not stop. */ 2191 2192 /* Are we stepping to get the inferior out of the dynamic 2193 linker's hook (and possibly the dld itself) after catching 2194 a shlib event? */ 2195 if (ecs->stepping_through_solib_after_catch) 2196 { 2197#if defined(SOLIB_ADD) 2198 /* Have we reached our destination? If not, keep going. */ 2199 if (SOLIB_IN_DYNAMIC_LINKER (PIDGET (ecs->ptid), stop_pc)) 2200 { 2201 ecs->another_trap = 1; 2202 keep_going (ecs); 2203 return; 2204 } 2205#endif 2206 /* Else, stop and report the catchpoint(s) whose triggering 2207 caused us to begin stepping. */ 2208 ecs->stepping_through_solib_after_catch = 0; 2209 bpstat_clear (&stop_bpstat); 2210 stop_bpstat = bpstat_copy (ecs->stepping_through_solib_catchpoints); 2211 bpstat_clear (&ecs->stepping_through_solib_catchpoints); 2212 stop_print_frame = 1; 2213 stop_stepping (ecs); 2214 return; 2215 } 2216 2217 if (step_resume_breakpoint) 2218 { 2219 /* Having a step-resume breakpoint overrides anything 2220 else having to do with stepping commands until 2221 that breakpoint is reached. */ 2222 keep_going (ecs); 2223 return; 2224 } 2225 2226 if (step_range_end == 0) 2227 { 2228 /* Likewise if we aren't even stepping. */ 2229 keep_going (ecs); 2230 return; 2231 } 2232 2233 /* If stepping through a line, keep going if still within it. 2234 2235 Note that step_range_end is the address of the first instruction 2236 beyond the step range, and NOT the address of the last instruction 2237 within it! */ 2238 if (stop_pc >= step_range_start && stop_pc < step_range_end) 2239 { 2240 keep_going (ecs); 2241 return; 2242 } 2243 2244 /* We stepped out of the stepping range. */ 2245 2246 /* If we are stepping at the source level and entered the runtime 2247 loader dynamic symbol resolution code, we keep on single stepping 2248 until we exit the run time loader code and reach the callee's 2249 address. */ 2250 if (step_over_calls == STEP_OVER_UNDEBUGGABLE 2251 && IN_SOLIB_DYNSYM_RESOLVE_CODE (stop_pc)) 2252 { 2253 CORE_ADDR pc_after_resolver = 2254 gdbarch_skip_solib_resolver (current_gdbarch, stop_pc); 2255 2256 if (pc_after_resolver) 2257 { 2258 /* Set up a step-resume breakpoint at the address 2259 indicated by SKIP_SOLIB_RESOLVER. */ 2260 struct symtab_and_line sr_sal; 2261 init_sal (&sr_sal); 2262 sr_sal.pc = pc_after_resolver; 2263 2264 insert_step_resume_breakpoint_at_sal (sr_sal, null_frame_id); 2265 } 2266 2267 keep_going (ecs); 2268 return; 2269 } 2270 2271 if (step_range_end != 1 2272 && (step_over_calls == STEP_OVER_UNDEBUGGABLE 2273 || step_over_calls == STEP_OVER_ALL) 2274 && get_frame_type (get_current_frame ()) == SIGTRAMP_FRAME) 2275 { 2276 /* The inferior, while doing a "step" or "next", has ended up in 2277 a signal trampoline (either by a signal being delivered or by 2278 the signal handler returning). Just single-step until the 2279 inferior leaves the trampoline (either by calling the handler 2280 or returning). */ 2281 keep_going (ecs); 2282 return; 2283 } 2284 2285 if (frame_id_eq (frame_unwind_id (get_current_frame ()), step_frame_id)) 2286 { 2287 /* It's a subroutine call. */ 2288 CORE_ADDR real_stop_pc; 2289 2290 if ((step_over_calls == STEP_OVER_NONE) 2291 || ((step_range_end == 1) 2292 && in_prologue (prev_pc, ecs->stop_func_start))) 2293 { 2294 /* I presume that step_over_calls is only 0 when we're 2295 supposed to be stepping at the assembly language level 2296 ("stepi"). Just stop. */ 2297 /* Also, maybe we just did a "nexti" inside a prolog, so we 2298 thought it was a subroutine call but it was not. Stop as 2299 well. FENN */ 2300 stop_step = 1; 2301 print_stop_reason (END_STEPPING_RANGE, 0); 2302 stop_stepping (ecs); 2303 return; 2304 } 2305 2306#ifdef DEPRECATED_IGNORE_HELPER_CALL 2307 /* On MIPS16, a function that returns a floating point value may 2308 call a library helper function to copy the return value to a 2309 floating point register. The DEPRECATED_IGNORE_HELPER_CALL 2310 macro returns non-zero if we should ignore (i.e. step over) 2311 this function call. */ 2312 /* FIXME: cagney/2004-07-21: These custom ``ignore frame when 2313 stepping'' function attributes (SIGTRAMP_FRAME, 2314 DEPRECATED_IGNORE_HELPER_CALL, SKIP_TRAMPOLINE_CODE, 2315 skip_language_trampoline frame, et.al.) need to be replaced 2316 with generic attributes bound to the frame's function. */ 2317 if (DEPRECATED_IGNORE_HELPER_CALL (stop_pc)) 2318 { 2319 /* We're doing a "next", set a breakpoint at callee's return 2320 address (the address at which the caller will 2321 resume). */ 2322 insert_step_resume_breakpoint_at_frame (get_prev_frame (get_current_frame ())); 2323 keep_going (ecs); 2324 return; 2325 } 2326#endif 2327 if (step_over_calls == STEP_OVER_ALL) 2328 { 2329 /* We're doing a "next", set a breakpoint at callee's return 2330 address (the address at which the caller will 2331 resume). */ 2332 insert_step_resume_breakpoint_at_frame (get_prev_frame (get_current_frame ())); 2333 keep_going (ecs); 2334 return; 2335 } 2336 2337 /* If we are in a function call trampoline (a stub between the 2338 calling routine and the real function), locate the real 2339 function. That's what tells us (a) whether we want to step 2340 into it at all, and (b) what prologue we want to run to the 2341 end of, if we do step into it. */ 2342 real_stop_pc = skip_language_trampoline (stop_pc); 2343 if (real_stop_pc == 0) 2344 real_stop_pc = SKIP_TRAMPOLINE_CODE (stop_pc); 2345 if (real_stop_pc != 0) 2346 ecs->stop_func_start = real_stop_pc; 2347 2348 if (IN_SOLIB_DYNSYM_RESOLVE_CODE (ecs->stop_func_start)) 2349 { 2350 struct symtab_and_line sr_sal; 2351 init_sal (&sr_sal); 2352 sr_sal.pc = ecs->stop_func_start; 2353 2354 insert_step_resume_breakpoint_at_sal (sr_sal, null_frame_id); 2355 keep_going (ecs); 2356 return; 2357 } 2358 2359 /* If we have line number information for the function we are 2360 thinking of stepping into, step into it. 2361 2362 If there are several symtabs at that PC (e.g. with include 2363 files), just want to know whether *any* of them have line 2364 numbers. find_pc_line handles this. */ 2365 { 2366 struct symtab_and_line tmp_sal; 2367 2368 tmp_sal = find_pc_line (ecs->stop_func_start, 0); 2369 if (tmp_sal.line != 0) 2370 { 2371 step_into_function (ecs); 2372 return; 2373 } 2374 } 2375 2376 /* If we have no line number and the step-stop-if-no-debug is 2377 set, we stop the step so that the user has a chance to switch 2378 in assembly mode. */ 2379 if (step_over_calls == STEP_OVER_UNDEBUGGABLE && step_stop_if_no_debug) 2380 { 2381 stop_step = 1; 2382 print_stop_reason (END_STEPPING_RANGE, 0); 2383 stop_stepping (ecs); 2384 return; 2385 } 2386 2387 /* Set a breakpoint at callee's return address (the address at 2388 which the caller will resume). */ 2389 insert_step_resume_breakpoint_at_frame (get_prev_frame (get_current_frame ())); 2390 keep_going (ecs); 2391 return; 2392 } 2393 2394 /* If we're in the return path from a shared library trampoline, 2395 we want to proceed through the trampoline when stepping. */ 2396 if (IN_SOLIB_RETURN_TRAMPOLINE (stop_pc, ecs->stop_func_name)) 2397 { 2398 /* Determine where this trampoline returns. */ 2399 CORE_ADDR real_stop_pc = SKIP_TRAMPOLINE_CODE (stop_pc); 2400 2401 /* Only proceed through if we know where it's going. */ 2402 if (real_stop_pc) 2403 { 2404 /* And put the step-breakpoint there and go until there. */ 2405 struct symtab_and_line sr_sal; 2406 2407 init_sal (&sr_sal); /* initialize to zeroes */ 2408 sr_sal.pc = real_stop_pc; 2409 sr_sal.section = find_pc_overlay (sr_sal.pc); 2410 2411 /* Do not specify what the fp should be when we stop since 2412 on some machines the prologue is where the new fp value 2413 is established. */ 2414 insert_step_resume_breakpoint_at_sal (sr_sal, null_frame_id); 2415 2416 /* Restart without fiddling with the step ranges or 2417 other state. */ 2418 keep_going (ecs); 2419 return; 2420 } 2421 } 2422 2423 /* NOTE: tausq/2004-05-24: This if block used to be done before all 2424 the trampoline processing logic, however, there are some trampolines 2425 that have no names, so we should do trampoline handling first. */ 2426 if (step_over_calls == STEP_OVER_UNDEBUGGABLE 2427 && ecs->stop_func_name == NULL) 2428 { 2429 /* The inferior just stepped into, or returned to, an 2430 undebuggable function (where there is no symbol, not even a 2431 minimal symbol, corresponding to the address where the 2432 inferior stopped). Since we want to skip this kind of code, 2433 we keep going until the inferior returns from this 2434 function. */ 2435 if (step_stop_if_no_debug) 2436 { 2437 /* If we have no line number and the step-stop-if-no-debug 2438 is set, we stop the step so that the user has a chance to 2439 switch in assembly mode. */ 2440 stop_step = 1; 2441 print_stop_reason (END_STEPPING_RANGE, 0); 2442 stop_stepping (ecs); 2443 return; 2444 } 2445 else 2446 { 2447 /* Set a breakpoint at callee's return address (the address 2448 at which the caller will resume). */ 2449 insert_step_resume_breakpoint_at_frame (get_prev_frame (get_current_frame ())); 2450 keep_going (ecs); 2451 return; 2452 } 2453 } 2454 2455 if (step_range_end == 1) 2456 { 2457 /* It is stepi or nexti. We always want to stop stepping after 2458 one instruction. */ 2459 stop_step = 1; 2460 print_stop_reason (END_STEPPING_RANGE, 0); 2461 stop_stepping (ecs); 2462 return; 2463 } 2464 2465 ecs->sal = find_pc_line (stop_pc, 0); 2466 2467 if (ecs->sal.line == 0) 2468 { 2469 /* We have no line number information. That means to stop 2470 stepping (does this always happen right after one instruction, 2471 when we do "s" in a function with no line numbers, 2472 or can this happen as a result of a return or longjmp?). */ 2473 stop_step = 1; 2474 print_stop_reason (END_STEPPING_RANGE, 0); 2475 stop_stepping (ecs); 2476 return; 2477 } 2478 2479 if ((stop_pc == ecs->sal.pc) 2480 && (ecs->current_line != ecs->sal.line 2481 || ecs->current_symtab != ecs->sal.symtab)) 2482 { 2483 /* We are at the start of a different line. So stop. Note that 2484 we don't stop if we step into the middle of a different line. 2485 That is said to make things like for (;;) statements work 2486 better. */ 2487 stop_step = 1; 2488 print_stop_reason (END_STEPPING_RANGE, 0); 2489 stop_stepping (ecs); 2490 return; 2491 } 2492 2493 /* We aren't done stepping. 2494 2495 Optimize by setting the stepping range to the line. 2496 (We might not be in the original line, but if we entered a 2497 new line in mid-statement, we continue stepping. This makes 2498 things like for(;;) statements work better.) */ 2499 2500 if (ecs->stop_func_end && ecs->sal.end >= ecs->stop_func_end) 2501 { 2502 /* If this is the last line of the function, don't keep stepping 2503 (it would probably step us out of the function). 2504 This is particularly necessary for a one-line function, 2505 in which after skipping the prologue we better stop even though 2506 we will be in mid-line. */ 2507 stop_step = 1; 2508 print_stop_reason (END_STEPPING_RANGE, 0); 2509 stop_stepping (ecs); 2510 return; 2511 } 2512 step_range_start = ecs->sal.pc; 2513 step_range_end = ecs->sal.end; 2514 step_frame_id = get_frame_id (get_current_frame ()); 2515 ecs->current_line = ecs->sal.line; 2516 ecs->current_symtab = ecs->sal.symtab; 2517 2518 /* In the case where we just stepped out of a function into the 2519 middle of a line of the caller, continue stepping, but 2520 step_frame_id must be modified to current frame */ 2521#if 0 2522 /* NOTE: cagney/2003-10-16: I think this frame ID inner test is too 2523 generous. It will trigger on things like a step into a frameless 2524 stackless leaf function. I think the logic should instead look 2525 at the unwound frame ID has that should give a more robust 2526 indication of what happened. */ 2527 if (step - ID == current - ID) 2528 still stepping in same function; 2529 else if (step - ID == unwind (current - ID)) 2530 stepped into a function; 2531 else 2532 stepped out of a function; 2533 /* Of course this assumes that the frame ID unwind code is robust 2534 and we're willing to introduce frame unwind logic into this 2535 function. Fortunately, those days are nearly upon us. */ 2536#endif 2537 { 2538 struct frame_id current_frame = get_frame_id (get_current_frame ()); 2539 if (!(frame_id_inner (current_frame, step_frame_id))) 2540 step_frame_id = current_frame; 2541 } 2542 2543 keep_going (ecs); 2544} 2545 2546/* Are we in the middle of stepping? */ 2547 2548static int 2549currently_stepping (struct execution_control_state *ecs) 2550{ 2551 return ((!ecs->handling_longjmp 2552 && ((step_range_end && step_resume_breakpoint == NULL) 2553 || trap_expected)) 2554 || ecs->stepping_through_solib_after_catch 2555 || bpstat_should_step ()); 2556} 2557 2558/* Subroutine call with source code we should not step over. Do step 2559 to the first line of code in it. */ 2560 2561static void 2562step_into_function (struct execution_control_state *ecs) 2563{ 2564 struct symtab *s; 2565 struct symtab_and_line sr_sal; 2566 2567 s = find_pc_symtab (stop_pc); 2568 if (s && s->language != language_asm) 2569 ecs->stop_func_start = SKIP_PROLOGUE (ecs->stop_func_start); 2570 2571 ecs->sal = find_pc_line (ecs->stop_func_start, 0); 2572 /* Use the step_resume_break to step until the end of the prologue, 2573 even if that involves jumps (as it seems to on the vax under 2574 4.2). */ 2575 /* If the prologue ends in the middle of a source line, continue to 2576 the end of that source line (if it is still within the function). 2577 Otherwise, just go to end of prologue. */ 2578 if (ecs->sal.end 2579 && ecs->sal.pc != ecs->stop_func_start 2580 && ecs->sal.end < ecs->stop_func_end) 2581 ecs->stop_func_start = ecs->sal.end; 2582 2583 /* Architectures which require breakpoint adjustment might not be able 2584 to place a breakpoint at the computed address. If so, the test 2585 ``ecs->stop_func_start == stop_pc'' will never succeed. Adjust 2586 ecs->stop_func_start to an address at which a breakpoint may be 2587 legitimately placed. 2588 2589 Note: kevinb/2004-01-19: On FR-V, if this adjustment is not 2590 made, GDB will enter an infinite loop when stepping through 2591 optimized code consisting of VLIW instructions which contain 2592 subinstructions corresponding to different source lines. On 2593 FR-V, it's not permitted to place a breakpoint on any but the 2594 first subinstruction of a VLIW instruction. When a breakpoint is 2595 set, GDB will adjust the breakpoint address to the beginning of 2596 the VLIW instruction. Thus, we need to make the corresponding 2597 adjustment here when computing the stop address. */ 2598 2599 if (gdbarch_adjust_breakpoint_address_p (current_gdbarch)) 2600 { 2601 ecs->stop_func_start 2602 = gdbarch_adjust_breakpoint_address (current_gdbarch, 2603 ecs->stop_func_start); 2604 } 2605 2606 if (ecs->stop_func_start == stop_pc) 2607 { 2608 /* We are already there: stop now. */ 2609 stop_step = 1; 2610 print_stop_reason (END_STEPPING_RANGE, 0); 2611 stop_stepping (ecs); 2612 return; 2613 } 2614 else 2615 { 2616 /* Put the step-breakpoint there and go until there. */ 2617 init_sal (&sr_sal); /* initialize to zeroes */ 2618 sr_sal.pc = ecs->stop_func_start; 2619 sr_sal.section = find_pc_overlay (ecs->stop_func_start); 2620 2621 /* Do not specify what the fp should be when we stop since on 2622 some machines the prologue is where the new fp value is 2623 established. */ 2624 insert_step_resume_breakpoint_at_sal (sr_sal, null_frame_id); 2625 2626 /* And make sure stepping stops right away then. */ 2627 step_range_end = step_range_start; 2628 } 2629 keep_going (ecs); 2630} 2631 2632/* Insert a "step resume breakpoint" at SR_SAL with frame ID SR_ID. 2633 This is used to both functions and to skip over code. */ 2634 2635static void 2636insert_step_resume_breakpoint_at_sal (struct symtab_and_line sr_sal, 2637 struct frame_id sr_id) 2638{ 2639 /* There should never be more than one step-resume breakpoint per 2640 thread, so we should never be setting a new 2641 step_resume_breakpoint when one is already active. */ 2642 gdb_assert (step_resume_breakpoint == NULL); 2643 step_resume_breakpoint = set_momentary_breakpoint (sr_sal, sr_id, 2644 bp_step_resume); 2645 if (breakpoints_inserted) 2646 insert_breakpoints (); 2647} 2648 2649/* Insert a "step resume breakpoint" at RETURN_FRAME.pc. This is used 2650 to skip a function (next, skip-no-debug) or signal. It's assumed 2651 that the function/signal handler being skipped eventually returns 2652 to the breakpoint inserted at RETURN_FRAME.pc. 2653 2654 For the skip-function case, the function may have been reached by 2655 either single stepping a call / return / signal-return instruction, 2656 or by hitting a breakpoint. In all cases, the RETURN_FRAME belongs 2657 to the skip-function's caller. 2658 2659 For the signals case, this is called with the interrupted 2660 function's frame. The signal handler, when it returns, will resume 2661 the interrupted function at RETURN_FRAME.pc. */ 2662 2663static void 2664insert_step_resume_breakpoint_at_frame (struct frame_info *return_frame) 2665{ 2666 struct symtab_and_line sr_sal; 2667 2668 init_sal (&sr_sal); /* initialize to zeros */ 2669 2670 sr_sal.pc = ADDR_BITS_REMOVE (get_frame_pc (return_frame)); 2671 sr_sal.section = find_pc_overlay (sr_sal.pc); 2672 2673 insert_step_resume_breakpoint_at_sal (sr_sal, get_frame_id (return_frame)); 2674} 2675 2676static void 2677stop_stepping (struct execution_control_state *ecs) 2678{ 2679 /* Let callers know we don't want to wait for the inferior anymore. */ 2680 ecs->wait_some_more = 0; 2681} 2682 2683/* This function handles various cases where we need to continue 2684 waiting for the inferior. */ 2685/* (Used to be the keep_going: label in the old wait_for_inferior) */ 2686 2687static void 2688keep_going (struct execution_control_state *ecs) 2689{ 2690 /* Save the pc before execution, to compare with pc after stop. */ 2691 prev_pc = read_pc (); /* Might have been DECR_AFTER_BREAK */ 2692 2693 /* If we did not do break;, it means we should keep running the 2694 inferior and not return to debugger. */ 2695 2696 if (trap_expected && stop_signal != TARGET_SIGNAL_TRAP) 2697 { 2698 /* We took a signal (which we are supposed to pass through to 2699 the inferior, else we'd have done a break above) and we 2700 haven't yet gotten our trap. Simply continue. */ 2701 resume (currently_stepping (ecs), stop_signal); 2702 } 2703 else 2704 { 2705 /* Either the trap was not expected, but we are continuing 2706 anyway (the user asked that this signal be passed to the 2707 child) 2708 -- or -- 2709 The signal was SIGTRAP, e.g. it was our signal, but we 2710 decided we should resume from it. 2711 2712 We're going to run this baby now! */ 2713 2714 if (!breakpoints_inserted && !ecs->another_trap) 2715 { 2716 breakpoints_failed = insert_breakpoints (); 2717 if (breakpoints_failed) 2718 { 2719 stop_stepping (ecs); 2720 return; 2721 } 2722 breakpoints_inserted = 1; 2723 } 2724 2725 trap_expected = ecs->another_trap; 2726 2727 /* Do not deliver SIGNAL_TRAP (except when the user explicitly 2728 specifies that such a signal should be delivered to the 2729 target program). 2730 2731 Typically, this would occure when a user is debugging a 2732 target monitor on a simulator: the target monitor sets a 2733 breakpoint; the simulator encounters this break-point and 2734 halts the simulation handing control to GDB; GDB, noteing 2735 that the break-point isn't valid, returns control back to the 2736 simulator; the simulator then delivers the hardware 2737 equivalent of a SIGNAL_TRAP to the program being debugged. */ 2738 2739 if (stop_signal == TARGET_SIGNAL_TRAP && !signal_program[stop_signal]) 2740 stop_signal = TARGET_SIGNAL_0; 2741 2742 2743 resume (currently_stepping (ecs), stop_signal); 2744 } 2745 2746 prepare_to_wait (ecs); 2747} 2748 2749/* This function normally comes after a resume, before 2750 handle_inferior_event exits. It takes care of any last bits of 2751 housekeeping, and sets the all-important wait_some_more flag. */ 2752 2753static void 2754prepare_to_wait (struct execution_control_state *ecs) 2755{ 2756 if (ecs->infwait_state == infwait_normal_state) 2757 { 2758 overlay_cache_invalid = 1; 2759 2760 /* We have to invalidate the registers BEFORE calling 2761 target_wait because they can be loaded from the target while 2762 in target_wait. This makes remote debugging a bit more 2763 efficient for those targets that provide critical registers 2764 as part of their normal status mechanism. */ 2765 2766 registers_changed (); 2767 ecs->waiton_ptid = pid_to_ptid (-1); 2768 ecs->wp = &(ecs->ws); 2769 } 2770 /* This is the old end of the while loop. Let everybody know we 2771 want to wait for the inferior some more and get called again 2772 soon. */ 2773 ecs->wait_some_more = 1; 2774} 2775 2776/* Print why the inferior has stopped. We always print something when 2777 the inferior exits, or receives a signal. The rest of the cases are 2778 dealt with later on in normal_stop() and print_it_typical(). Ideally 2779 there should be a call to this function from handle_inferior_event() 2780 each time stop_stepping() is called.*/ 2781static void 2782print_stop_reason (enum inferior_stop_reason stop_reason, int stop_info) 2783{ 2784 switch (stop_reason) 2785 { 2786 case STOP_UNKNOWN: 2787 /* We don't deal with these cases from handle_inferior_event() 2788 yet. */ 2789 break; 2790 case END_STEPPING_RANGE: 2791 /* We are done with a step/next/si/ni command. */ 2792 /* For now print nothing. */ 2793 /* Print a message only if not in the middle of doing a "step n" 2794 operation for n > 1 */ 2795 if (!step_multi || !stop_step) 2796 if (ui_out_is_mi_like_p (uiout)) 2797 ui_out_field_string (uiout, "reason", "end-stepping-range"); 2798 break; 2799 case BREAKPOINT_HIT: 2800 /* We found a breakpoint. */ 2801 /* For now print nothing. */ 2802 break; 2803 case SIGNAL_EXITED: 2804 /* The inferior was terminated by a signal. */ 2805 annotate_signalled (); 2806 if (ui_out_is_mi_like_p (uiout)) 2807 ui_out_field_string (uiout, "reason", "exited-signalled"); 2808 ui_out_text (uiout, "\nProgram terminated with signal "); 2809 annotate_signal_name (); 2810 ui_out_field_string (uiout, "signal-name", 2811 target_signal_to_name (stop_info)); 2812 annotate_signal_name_end (); 2813 ui_out_text (uiout, ", "); 2814 annotate_signal_string (); 2815 ui_out_field_string (uiout, "signal-meaning", 2816 target_signal_to_string (stop_info)); 2817 annotate_signal_string_end (); 2818 ui_out_text (uiout, ".\n"); 2819 ui_out_text (uiout, "The program no longer exists.\n"); 2820 break; 2821 case EXITED: 2822 /* The inferior program is finished. */ 2823 annotate_exited (stop_info); 2824 if (stop_info) 2825 { 2826 if (ui_out_is_mi_like_p (uiout)) 2827 ui_out_field_string (uiout, "reason", "exited"); 2828 ui_out_text (uiout, "\nProgram exited with code "); 2829 ui_out_field_fmt (uiout, "exit-code", "0%o", 2830 (unsigned int) stop_info); 2831 ui_out_text (uiout, ".\n"); 2832 } 2833 else 2834 { 2835 if (ui_out_is_mi_like_p (uiout)) 2836 ui_out_field_string (uiout, "reason", "exited-normally"); 2837 ui_out_text (uiout, "\nProgram exited normally.\n"); 2838 } 2839 break; 2840 case SIGNAL_RECEIVED: 2841 /* Signal received. The signal table tells us to print about 2842 it. */ 2843 annotate_signal (); 2844 ui_out_text (uiout, "\nProgram received signal "); 2845 annotate_signal_name (); 2846 if (ui_out_is_mi_like_p (uiout)) 2847 ui_out_field_string (uiout, "reason", "signal-received"); 2848 ui_out_field_string (uiout, "signal-name", 2849 target_signal_to_name (stop_info)); 2850 annotate_signal_name_end (); 2851 ui_out_text (uiout, ", "); 2852 annotate_signal_string (); 2853 ui_out_field_string (uiout, "signal-meaning", 2854 target_signal_to_string (stop_info)); 2855 annotate_signal_string_end (); 2856 ui_out_text (uiout, ".\n"); 2857 break; 2858 default: 2859 internal_error (__FILE__, __LINE__, 2860 "print_stop_reason: unrecognized enum value"); 2861 break; 2862 } 2863} 2864 2865 2866/* Here to return control to GDB when the inferior stops for real. 2867 Print appropriate messages, remove breakpoints, give terminal our modes. 2868 2869 STOP_PRINT_FRAME nonzero means print the executing frame 2870 (pc, function, args, file, line number and line text). 2871 BREAKPOINTS_FAILED nonzero means stop was due to error 2872 attempting to insert breakpoints. */ 2873 2874void 2875normal_stop (void) 2876{ 2877 struct target_waitstatus last; 2878 ptid_t last_ptid; 2879 2880 get_last_target_status (&last_ptid, &last); 2881 2882 /* As with the notification of thread events, we want to delay 2883 notifying the user that we've switched thread context until 2884 the inferior actually stops. 2885 2886 There's no point in saying anything if the inferior has exited. 2887 Note that SIGNALLED here means "exited with a signal", not 2888 "received a signal". */ 2889 if (!ptid_equal (previous_inferior_ptid, inferior_ptid) 2890 && target_has_execution 2891 && last.kind != TARGET_WAITKIND_SIGNALLED 2892 && last.kind != TARGET_WAITKIND_EXITED) 2893 { 2894 target_terminal_ours_for_output (); 2895 printf_filtered ("[Switching to %s]\n", 2896 target_pid_or_tid_to_str (inferior_ptid)); 2897 previous_inferior_ptid = inferior_ptid; 2898 } 2899 2900 /* NOTE drow/2004-01-17: Is this still necessary? */ 2901 /* Make sure that the current_frame's pc is correct. This 2902 is a correction for setting up the frame info before doing 2903 DECR_PC_AFTER_BREAK */ 2904 if (target_has_execution) 2905 /* FIXME: cagney/2002-12-06: Has the PC changed? Thanks to 2906 DECR_PC_AFTER_BREAK, the program counter can change. Ask the 2907 frame code to check for this and sort out any resultant mess. 2908 DECR_PC_AFTER_BREAK needs to just go away. */ 2909 deprecated_update_frame_pc_hack (get_current_frame (), read_pc ()); 2910 2911 if (target_has_execution && breakpoints_inserted) 2912 { 2913 if (remove_breakpoints ()) 2914 { 2915 target_terminal_ours_for_output (); 2916 printf_filtered ("Cannot remove breakpoints because "); 2917 printf_filtered ("program is no longer writable.\n"); 2918 printf_filtered ("It might be running in another process.\n"); 2919 printf_filtered ("Further execution is probably impossible.\n"); 2920 } 2921 } 2922 breakpoints_inserted = 0; 2923 2924 /* Delete the breakpoint we stopped at, if it wants to be deleted. 2925 Delete any breakpoint that is to be deleted at the next stop. */ 2926 2927 breakpoint_auto_delete (stop_bpstat); 2928 2929 /* If an auto-display called a function and that got a signal, 2930 delete that auto-display to avoid an infinite recursion. */ 2931 2932 if (stopped_by_random_signal) 2933 disable_current_display (); 2934 2935 /* Don't print a message if in the middle of doing a "step n" 2936 operation for n > 1 */ 2937 if (step_multi && stop_step) 2938 goto done; 2939 2940 target_terminal_ours (); 2941 2942 /* Look up the hook_stop and run it (CLI internally handles problem 2943 of stop_command's pre-hook not existing). */ 2944 if (stop_command) 2945 catch_errors (hook_stop_stub, stop_command, 2946 "Error while running hook_stop:\n", RETURN_MASK_ALL); 2947 2948 if (!target_has_stack) 2949 { 2950 2951 goto done; 2952 } 2953 2954 /* Select innermost stack frame - i.e., current frame is frame 0, 2955 and current location is based on that. 2956 Don't do this on return from a stack dummy routine, 2957 or if the program has exited. */ 2958 2959 if (!stop_stack_dummy) 2960 { 2961 select_frame (get_current_frame ()); 2962 2963 /* Print current location without a level number, if 2964 we have changed functions or hit a breakpoint. 2965 Print source line if we have one. 2966 bpstat_print() contains the logic deciding in detail 2967 what to print, based on the event(s) that just occurred. */ 2968 2969 if (stop_print_frame && deprecated_selected_frame) 2970 { 2971 int bpstat_ret; 2972 int source_flag; 2973 int do_frame_printing = 1; 2974 2975 bpstat_ret = bpstat_print (stop_bpstat); 2976 switch (bpstat_ret) 2977 { 2978 case PRINT_UNKNOWN: 2979 /* FIXME: cagney/2002-12-01: Given that a frame ID does 2980 (or should) carry around the function and does (or 2981 should) use that when doing a frame comparison. */ 2982 if (stop_step 2983 && frame_id_eq (step_frame_id, 2984 get_frame_id (get_current_frame ())) 2985 && step_start_function == find_pc_function (stop_pc)) 2986 source_flag = SRC_LINE; /* finished step, just print source line */ 2987 else 2988 source_flag = SRC_AND_LOC; /* print location and source line */ 2989 break; 2990 case PRINT_SRC_AND_LOC: 2991 source_flag = SRC_AND_LOC; /* print location and source line */ 2992 break; 2993 case PRINT_SRC_ONLY: 2994 source_flag = SRC_LINE; 2995 break; 2996 case PRINT_NOTHING: 2997 source_flag = SRC_LINE; /* something bogus */ 2998 do_frame_printing = 0; 2999 break; 3000 default: 3001 internal_error (__FILE__, __LINE__, "Unknown value."); 3002 } 3003 /* For mi, have the same behavior every time we stop: 3004 print everything but the source line. */ 3005 if (ui_out_is_mi_like_p (uiout)) 3006 source_flag = LOC_AND_ADDRESS; 3007 3008 if (ui_out_is_mi_like_p (uiout)) 3009 ui_out_field_int (uiout, "thread-id", 3010 pid_to_thread_id (inferior_ptid)); 3011 /* The behavior of this routine with respect to the source 3012 flag is: 3013 SRC_LINE: Print only source line 3014 LOCATION: Print only location 3015 SRC_AND_LOC: Print location and source line */ 3016 if (do_frame_printing) 3017 print_stack_frame (get_selected_frame (), 0, source_flag); 3018 3019 /* Display the auto-display expressions. */ 3020 do_displays (); 3021 } 3022 } 3023 3024 /* Save the function value return registers, if we care. 3025 We might be about to restore their previous contents. */ 3026 if (proceed_to_finish) 3027 /* NB: The copy goes through to the target picking up the value of 3028 all the registers. */ 3029 regcache_cpy (stop_registers, current_regcache); 3030 3031 if (stop_stack_dummy) 3032 { 3033 /* Pop the empty frame that contains the stack dummy. POP_FRAME 3034 ends with a setting of the current frame, so we can use that 3035 next. */ 3036 frame_pop (get_current_frame ()); 3037 /* Set stop_pc to what it was before we called the function. 3038 Can't rely on restore_inferior_status because that only gets 3039 called if we don't stop in the called function. */ 3040 stop_pc = read_pc (); 3041 select_frame (get_current_frame ()); 3042 } 3043 3044done: 3045 annotate_stopped (); 3046 observer_notify_normal_stop (stop_bpstat); 3047} 3048 3049static int 3050hook_stop_stub (void *cmd) 3051{ 3052 execute_cmd_pre_hook ((struct cmd_list_element *) cmd); 3053 return (0); 3054} 3055 3056int 3057signal_stop_state (int signo) 3058{ 3059 return signal_stop[signo]; 3060} 3061 3062int 3063signal_print_state (int signo) 3064{ 3065 return signal_print[signo]; 3066} 3067 3068int 3069signal_pass_state (int signo) 3070{ 3071 return signal_program[signo]; 3072} 3073 3074int 3075signal_stop_update (int signo, int state) 3076{ 3077 int ret = signal_stop[signo]; 3078 signal_stop[signo] = state; 3079 return ret; 3080} 3081 3082int 3083signal_print_update (int signo, int state) 3084{ 3085 int ret = signal_print[signo]; 3086 signal_print[signo] = state; 3087 return ret; 3088} 3089 3090int 3091signal_pass_update (int signo, int state) 3092{ 3093 int ret = signal_program[signo]; 3094 signal_program[signo] = state; 3095 return ret; 3096} 3097 3098static void 3099sig_print_header (void) 3100{ 3101 printf_filtered ("\ 3102Signal Stop\tPrint\tPass to program\tDescription\n"); 3103} 3104 3105static void 3106sig_print_info (enum target_signal oursig) 3107{ 3108 char *name = target_signal_to_name (oursig); 3109 int name_padding = 13 - strlen (name); 3110 3111 if (name_padding <= 0) 3112 name_padding = 0; 3113 3114 printf_filtered ("%s", name); 3115 printf_filtered ("%*.*s ", name_padding, name_padding, " "); 3116 printf_filtered ("%s\t", signal_stop[oursig] ? "Yes" : "No"); 3117 printf_filtered ("%s\t", signal_print[oursig] ? "Yes" : "No"); 3118 printf_filtered ("%s\t\t", signal_program[oursig] ? "Yes" : "No"); 3119 printf_filtered ("%s\n", target_signal_to_string (oursig)); 3120} 3121 3122/* Specify how various signals in the inferior should be handled. */ 3123 3124static void 3125handle_command (char *args, int from_tty) 3126{ 3127 char **argv; 3128 int digits, wordlen; 3129 int sigfirst, signum, siglast; 3130 enum target_signal oursig; 3131 int allsigs; 3132 int nsigs; 3133 unsigned char *sigs; 3134 struct cleanup *old_chain; 3135 3136 if (args == NULL) 3137 { 3138 error_no_arg ("signal to handle"); 3139 } 3140 3141 /* Allocate and zero an array of flags for which signals to handle. */ 3142 3143 nsigs = (int) TARGET_SIGNAL_LAST; 3144 sigs = (unsigned char *) alloca (nsigs); 3145 memset (sigs, 0, nsigs); 3146 3147 /* Break the command line up into args. */ 3148 3149 argv = buildargv (args); 3150 if (argv == NULL) 3151 { 3152 nomem (0); 3153 } 3154 old_chain = make_cleanup_freeargv (argv); 3155 3156 /* Walk through the args, looking for signal oursigs, signal names, and 3157 actions. Signal numbers and signal names may be interspersed with 3158 actions, with the actions being performed for all signals cumulatively 3159 specified. Signal ranges can be specified as <LOW>-<HIGH>. */ 3160 3161 while (*argv != NULL) 3162 { 3163 wordlen = strlen (*argv); 3164 for (digits = 0; isdigit ((*argv)[digits]); digits++) 3165 {; 3166 } 3167 allsigs = 0; 3168 sigfirst = siglast = -1; 3169 3170 if (wordlen >= 1 && !strncmp (*argv, "all", wordlen)) 3171 { 3172 /* Apply action to all signals except those used by the 3173 debugger. Silently skip those. */ 3174 allsigs = 1; 3175 sigfirst = 0; 3176 siglast = nsigs - 1; 3177 } 3178 else if (wordlen >= 1 && !strncmp (*argv, "stop", wordlen)) 3179 { 3180 SET_SIGS (nsigs, sigs, signal_stop); 3181 SET_SIGS (nsigs, sigs, signal_print); 3182 } 3183 else if (wordlen >= 1 && !strncmp (*argv, "ignore", wordlen)) 3184 { 3185 UNSET_SIGS (nsigs, sigs, signal_program); 3186 } 3187 else if (wordlen >= 2 && !strncmp (*argv, "print", wordlen)) 3188 { 3189 SET_SIGS (nsigs, sigs, signal_print); 3190 } 3191 else if (wordlen >= 2 && !strncmp (*argv, "pass", wordlen)) 3192 { 3193 SET_SIGS (nsigs, sigs, signal_program); 3194 } 3195 else if (wordlen >= 3 && !strncmp (*argv, "nostop", wordlen)) 3196 { 3197 UNSET_SIGS (nsigs, sigs, signal_stop); 3198 } 3199 else if (wordlen >= 3 && !strncmp (*argv, "noignore", wordlen)) 3200 { 3201 SET_SIGS (nsigs, sigs, signal_program); 3202 } 3203 else if (wordlen >= 4 && !strncmp (*argv, "noprint", wordlen)) 3204 { 3205 UNSET_SIGS (nsigs, sigs, signal_print); 3206 UNSET_SIGS (nsigs, sigs, signal_stop); 3207 } 3208 else if (wordlen >= 4 && !strncmp (*argv, "nopass", wordlen)) 3209 { 3210 UNSET_SIGS (nsigs, sigs, signal_program); 3211 } 3212 else if (digits > 0) 3213 { 3214 /* It is numeric. The numeric signal refers to our own 3215 internal signal numbering from target.h, not to host/target 3216 signal number. This is a feature; users really should be 3217 using symbolic names anyway, and the common ones like 3218 SIGHUP, SIGINT, SIGALRM, etc. will work right anyway. */ 3219 3220 sigfirst = siglast = (int) 3221 target_signal_from_command (atoi (*argv)); 3222 if ((*argv)[digits] == '-') 3223 { 3224 siglast = (int) 3225 target_signal_from_command (atoi ((*argv) + digits + 1)); 3226 } 3227 if (sigfirst > siglast) 3228 { 3229 /* Bet he didn't figure we'd think of this case... */ 3230 signum = sigfirst; 3231 sigfirst = siglast; 3232 siglast = signum; 3233 } 3234 } 3235 else 3236 { 3237 oursig = target_signal_from_name (*argv); 3238 if (oursig != TARGET_SIGNAL_UNKNOWN) 3239 { 3240 sigfirst = siglast = (int) oursig; 3241 } 3242 else 3243 { 3244 /* Not a number and not a recognized flag word => complain. */ 3245 error ("Unrecognized or ambiguous flag word: \"%s\".", *argv); 3246 } 3247 } 3248 3249 /* If any signal numbers or symbol names were found, set flags for 3250 which signals to apply actions to. */ 3251 3252 for (signum = sigfirst; signum >= 0 && signum <= siglast; signum++) 3253 { 3254 switch ((enum target_signal) signum) 3255 { 3256 case TARGET_SIGNAL_TRAP: 3257 case TARGET_SIGNAL_INT: 3258 if (!allsigs && !sigs[signum]) 3259 { 3260 if (query ("%s is used by the debugger.\n\ 3261Are you sure you want to change it? ", target_signal_to_name ((enum target_signal) signum))) 3262 { 3263 sigs[signum] = 1; 3264 } 3265 else 3266 { 3267 printf_unfiltered ("Not confirmed, unchanged.\n"); 3268 gdb_flush (gdb_stdout); 3269 } 3270 } 3271 break; 3272 case TARGET_SIGNAL_0: 3273 case TARGET_SIGNAL_DEFAULT: 3274 case TARGET_SIGNAL_UNKNOWN: 3275 /* Make sure that "all" doesn't print these. */ 3276 break; 3277 default: 3278 sigs[signum] = 1; 3279 break; 3280 } 3281 } 3282 3283 argv++; 3284 } 3285 3286 target_notice_signals (inferior_ptid); 3287 3288 if (from_tty) 3289 { 3290 /* Show the results. */ 3291 sig_print_header (); 3292 for (signum = 0; signum < nsigs; signum++) 3293 { 3294 if (sigs[signum]) 3295 { 3296 sig_print_info (signum); 3297 } 3298 } 3299 } 3300 3301 do_cleanups (old_chain); 3302} 3303 3304static void 3305xdb_handle_command (char *args, int from_tty) 3306{ 3307 char **argv; 3308 struct cleanup *old_chain; 3309 3310 /* Break the command line up into args. */ 3311 3312 argv = buildargv (args); 3313 if (argv == NULL) 3314 { 3315 nomem (0); 3316 } 3317 old_chain = make_cleanup_freeargv (argv); 3318 if (argv[1] != (char *) NULL) 3319 { 3320 char *argBuf; 3321 int bufLen; 3322 3323 bufLen = strlen (argv[0]) + 20; 3324 argBuf = (char *) xmalloc (bufLen); 3325 if (argBuf) 3326 { 3327 int validFlag = 1; 3328 enum target_signal oursig; 3329 3330 oursig = target_signal_from_name (argv[0]); 3331 memset (argBuf, 0, bufLen); 3332 if (strcmp (argv[1], "Q") == 0) 3333 sprintf (argBuf, "%s %s", argv[0], "noprint"); 3334 else 3335 { 3336 if (strcmp (argv[1], "s") == 0) 3337 { 3338 if (!signal_stop[oursig]) 3339 sprintf (argBuf, "%s %s", argv[0], "stop"); 3340 else 3341 sprintf (argBuf, "%s %s", argv[0], "nostop"); 3342 } 3343 else if (strcmp (argv[1], "i") == 0) 3344 { 3345 if (!signal_program[oursig]) 3346 sprintf (argBuf, "%s %s", argv[0], "pass"); 3347 else 3348 sprintf (argBuf, "%s %s", argv[0], "nopass"); 3349 } 3350 else if (strcmp (argv[1], "r") == 0) 3351 { 3352 if (!signal_print[oursig]) 3353 sprintf (argBuf, "%s %s", argv[0], "print"); 3354 else 3355 sprintf (argBuf, "%s %s", argv[0], "noprint"); 3356 } 3357 else 3358 validFlag = 0; 3359 } 3360 if (validFlag) 3361 handle_command (argBuf, from_tty); 3362 else 3363 printf_filtered ("Invalid signal handling flag.\n"); 3364 if (argBuf) 3365 xfree (argBuf); 3366 } 3367 } 3368 do_cleanups (old_chain); 3369} 3370 3371/* Print current contents of the tables set by the handle command. 3372 It is possible we should just be printing signals actually used 3373 by the current target (but for things to work right when switching 3374 targets, all signals should be in the signal tables). */ 3375 3376static void 3377signals_info (char *signum_exp, int from_tty) 3378{ 3379 enum target_signal oursig; 3380 sig_print_header (); 3381 3382 if (signum_exp) 3383 { 3384 /* First see if this is a symbol name. */ 3385 oursig = target_signal_from_name (signum_exp); 3386 if (oursig == TARGET_SIGNAL_UNKNOWN) 3387 { 3388 /* No, try numeric. */ 3389 oursig = 3390 target_signal_from_command (parse_and_eval_long (signum_exp)); 3391 } 3392 sig_print_info (oursig); 3393 return; 3394 } 3395 3396 printf_filtered ("\n"); 3397 /* These ugly casts brought to you by the native VAX compiler. */ 3398 for (oursig = TARGET_SIGNAL_FIRST; 3399 (int) oursig < (int) TARGET_SIGNAL_LAST; 3400 oursig = (enum target_signal) ((int) oursig + 1)) 3401 { 3402 QUIT; 3403 3404 if (oursig != TARGET_SIGNAL_UNKNOWN 3405 && oursig != TARGET_SIGNAL_DEFAULT && oursig != TARGET_SIGNAL_0) 3406 sig_print_info (oursig); 3407 } 3408 3409 printf_filtered ("\nUse the \"handle\" command to change these tables.\n"); 3410} 3411 3412struct inferior_status 3413{ 3414 enum target_signal stop_signal; 3415 CORE_ADDR stop_pc; 3416 bpstat stop_bpstat; 3417 int stop_step; 3418 int stop_stack_dummy; 3419 int stopped_by_random_signal; 3420 int trap_expected; 3421 CORE_ADDR step_range_start; 3422 CORE_ADDR step_range_end; 3423 struct frame_id step_frame_id; 3424 enum step_over_calls_kind step_over_calls; 3425 CORE_ADDR step_resume_break_address; 3426 int stop_after_trap; 3427 int stop_soon; 3428 struct regcache *stop_registers; 3429 3430 /* These are here because if call_function_by_hand has written some 3431 registers and then decides to call error(), we better not have changed 3432 any registers. */ 3433 struct regcache *registers; 3434 3435 /* A frame unique identifier. */ 3436 struct frame_id selected_frame_id; 3437 3438 int breakpoint_proceeded; 3439 int restore_stack_info; 3440 int proceed_to_finish; 3441}; 3442 3443void 3444write_inferior_status_register (struct inferior_status *inf_status, int regno, 3445 LONGEST val) 3446{ 3447 int size = register_size (current_gdbarch, regno); 3448 void *buf = alloca (size); 3449 store_signed_integer (buf, size, val); 3450 regcache_raw_write (inf_status->registers, regno, buf); 3451} 3452 3453/* Save all of the information associated with the inferior<==>gdb 3454 connection. INF_STATUS is a pointer to a "struct inferior_status" 3455 (defined in inferior.h). */ 3456 3457struct inferior_status * 3458save_inferior_status (int restore_stack_info) 3459{ 3460 struct inferior_status *inf_status = XMALLOC (struct inferior_status); 3461 3462 inf_status->stop_signal = stop_signal; 3463 inf_status->stop_pc = stop_pc; 3464 inf_status->stop_step = stop_step; 3465 inf_status->stop_stack_dummy = stop_stack_dummy; 3466 inf_status->stopped_by_random_signal = stopped_by_random_signal; 3467 inf_status->trap_expected = trap_expected; 3468 inf_status->step_range_start = step_range_start; 3469 inf_status->step_range_end = step_range_end; 3470 inf_status->step_frame_id = step_frame_id; 3471 inf_status->step_over_calls = step_over_calls; 3472 inf_status->stop_after_trap = stop_after_trap; 3473 inf_status->stop_soon = stop_soon; 3474 /* Save original bpstat chain here; replace it with copy of chain. 3475 If caller's caller is walking the chain, they'll be happier if we 3476 hand them back the original chain when restore_inferior_status is 3477 called. */ 3478 inf_status->stop_bpstat = stop_bpstat; 3479 stop_bpstat = bpstat_copy (stop_bpstat); 3480 inf_status->breakpoint_proceeded = breakpoint_proceeded; 3481 inf_status->restore_stack_info = restore_stack_info; 3482 inf_status->proceed_to_finish = proceed_to_finish; 3483 3484 inf_status->stop_registers = regcache_dup_no_passthrough (stop_registers); 3485 3486 inf_status->registers = regcache_dup (current_regcache); 3487 3488 inf_status->selected_frame_id = get_frame_id (deprecated_selected_frame); 3489 return inf_status; 3490} 3491 3492static int 3493restore_selected_frame (void *args) 3494{ 3495 struct frame_id *fid = (struct frame_id *) args; 3496 struct frame_info *frame; 3497 3498 frame = frame_find_by_id (*fid); 3499 3500 /* If inf_status->selected_frame_id is NULL, there was no previously 3501 selected frame. */ 3502 if (frame == NULL) 3503 { 3504 warning ("Unable to restore previously selected frame.\n"); 3505 return 0; 3506 } 3507 3508 select_frame (frame); 3509 3510 return (1); 3511} 3512 3513void 3514restore_inferior_status (struct inferior_status *inf_status) 3515{ 3516 stop_signal = inf_status->stop_signal; 3517 stop_pc = inf_status->stop_pc; 3518 stop_step = inf_status->stop_step; 3519 stop_stack_dummy = inf_status->stop_stack_dummy; 3520 stopped_by_random_signal = inf_status->stopped_by_random_signal; 3521 trap_expected = inf_status->trap_expected; 3522 step_range_start = inf_status->step_range_start; 3523 step_range_end = inf_status->step_range_end; 3524 step_frame_id = inf_status->step_frame_id; 3525 step_over_calls = inf_status->step_over_calls; 3526 stop_after_trap = inf_status->stop_after_trap; 3527 stop_soon = inf_status->stop_soon; 3528 bpstat_clear (&stop_bpstat); 3529 stop_bpstat = inf_status->stop_bpstat; 3530 breakpoint_proceeded = inf_status->breakpoint_proceeded; 3531 proceed_to_finish = inf_status->proceed_to_finish; 3532 3533 /* FIXME: Is the restore of stop_registers always needed. */ 3534 regcache_xfree (stop_registers); 3535 stop_registers = inf_status->stop_registers; 3536 3537 /* The inferior can be gone if the user types "print exit(0)" 3538 (and perhaps other times). */ 3539 if (target_has_execution) 3540 /* NB: The register write goes through to the target. */ 3541 regcache_cpy (current_regcache, inf_status->registers); 3542 regcache_xfree (inf_status->registers); 3543 3544 /* FIXME: If we are being called after stopping in a function which 3545 is called from gdb, we should not be trying to restore the 3546 selected frame; it just prints a spurious error message (The 3547 message is useful, however, in detecting bugs in gdb (like if gdb 3548 clobbers the stack)). In fact, should we be restoring the 3549 inferior status at all in that case? . */ 3550 3551 if (target_has_stack && inf_status->restore_stack_info) 3552 { 3553 /* The point of catch_errors is that if the stack is clobbered, 3554 walking the stack might encounter a garbage pointer and 3555 error() trying to dereference it. */ 3556 if (catch_errors 3557 (restore_selected_frame, &inf_status->selected_frame_id, 3558 "Unable to restore previously selected frame:\n", 3559 RETURN_MASK_ERROR) == 0) 3560 /* Error in restoring the selected frame. Select the innermost 3561 frame. */ 3562 select_frame (get_current_frame ()); 3563 3564 } 3565 3566 xfree (inf_status); 3567} 3568 3569static void 3570do_restore_inferior_status_cleanup (void *sts) 3571{ 3572 restore_inferior_status (sts); 3573} 3574 3575struct cleanup * 3576make_cleanup_restore_inferior_status (struct inferior_status *inf_status) 3577{ 3578 return make_cleanup (do_restore_inferior_status_cleanup, inf_status); 3579} 3580 3581void 3582discard_inferior_status (struct inferior_status *inf_status) 3583{ 3584 /* See save_inferior_status for info on stop_bpstat. */ 3585 bpstat_clear (&inf_status->stop_bpstat); 3586 regcache_xfree (inf_status->registers); 3587 regcache_xfree (inf_status->stop_registers); 3588 xfree (inf_status); 3589} 3590 3591int 3592inferior_has_forked (int pid, int *child_pid) 3593{ 3594 struct target_waitstatus last; 3595 ptid_t last_ptid; 3596 3597 get_last_target_status (&last_ptid, &last); 3598 3599 if (last.kind != TARGET_WAITKIND_FORKED) 3600 return 0; 3601 3602 if (ptid_get_pid (last_ptid) != pid) 3603 return 0; 3604 3605 *child_pid = last.value.related_pid; 3606 return 1; 3607} 3608 3609int 3610inferior_has_vforked (int pid, int *child_pid) 3611{ 3612 struct target_waitstatus last; 3613 ptid_t last_ptid; 3614 3615 get_last_target_status (&last_ptid, &last); 3616 3617 if (last.kind != TARGET_WAITKIND_VFORKED) 3618 return 0; 3619 3620 if (ptid_get_pid (last_ptid) != pid) 3621 return 0; 3622 3623 *child_pid = last.value.related_pid; 3624 return 1; 3625} 3626 3627int 3628inferior_has_execd (int pid, char **execd_pathname) 3629{ 3630 struct target_waitstatus last; 3631 ptid_t last_ptid; 3632 3633 get_last_target_status (&last_ptid, &last); 3634 3635 if (last.kind != TARGET_WAITKIND_EXECD) 3636 return 0; 3637 3638 if (ptid_get_pid (last_ptid) != pid) 3639 return 0; 3640 3641 *execd_pathname = xstrdup (last.value.execd_pathname); 3642 return 1; 3643} 3644 3645/* Oft used ptids */ 3646ptid_t null_ptid; 3647ptid_t minus_one_ptid; 3648 3649/* Create a ptid given the necessary PID, LWP, and TID components. */ 3650 3651ptid_t 3652ptid_build (int pid, long lwp, long tid) 3653{ 3654 ptid_t ptid; 3655 3656 ptid.pid = pid; 3657 ptid.lwp = lwp; 3658 ptid.tid = tid; 3659 return ptid; 3660} 3661 3662/* Create a ptid from just a pid. */ 3663 3664ptid_t 3665pid_to_ptid (int pid) 3666{ 3667 return ptid_build (pid, 0, 0); 3668} 3669 3670/* Fetch the pid (process id) component from a ptid. */ 3671 3672int 3673ptid_get_pid (ptid_t ptid) 3674{ 3675 return ptid.pid; 3676} 3677 3678/* Fetch the lwp (lightweight process) component from a ptid. */ 3679 3680long 3681ptid_get_lwp (ptid_t ptid) 3682{ 3683 return ptid.lwp; 3684} 3685 3686/* Fetch the tid (thread id) component from a ptid. */ 3687 3688long 3689ptid_get_tid (ptid_t ptid) 3690{ 3691 return ptid.tid; 3692} 3693 3694/* ptid_equal() is used to test equality of two ptids. */ 3695 3696int 3697ptid_equal (ptid_t ptid1, ptid_t ptid2) 3698{ 3699 return (ptid1.pid == ptid2.pid && ptid1.lwp == ptid2.lwp 3700 && ptid1.tid == ptid2.tid); 3701} 3702 3703/* restore_inferior_ptid() will be used by the cleanup machinery 3704 to restore the inferior_ptid value saved in a call to 3705 save_inferior_ptid(). */ 3706 3707static void 3708restore_inferior_ptid (void *arg) 3709{ 3710 ptid_t *saved_ptid_ptr = arg; 3711 inferior_ptid = *saved_ptid_ptr; 3712 xfree (arg); 3713} 3714 3715/* Save the value of inferior_ptid so that it may be restored by a 3716 later call to do_cleanups(). Returns the struct cleanup pointer 3717 needed for later doing the cleanup. */ 3718 3719struct cleanup * 3720save_inferior_ptid (void) 3721{ 3722 ptid_t *saved_ptid_ptr; 3723 3724 saved_ptid_ptr = xmalloc (sizeof (ptid_t)); 3725 *saved_ptid_ptr = inferior_ptid; 3726 return make_cleanup (restore_inferior_ptid, saved_ptid_ptr); 3727} 3728 3729 3730static void 3731build_infrun (void) 3732{ 3733 stop_registers = regcache_xmalloc (current_gdbarch); 3734} 3735 3736void 3737_initialize_infrun (void) 3738{ 3739 int i; 3740 int numsigs; 3741 struct cmd_list_element *c; 3742 3743 DEPRECATED_REGISTER_GDBARCH_SWAP (stop_registers); 3744 deprecated_register_gdbarch_swap (NULL, 0, build_infrun); 3745 3746 add_info ("signals", signals_info, 3747 "What debugger does when program gets various signals.\n\ 3748Specify a signal as argument to print info on that signal only."); 3749 add_info_alias ("handle", "signals", 0); 3750 3751 add_com ("handle", class_run, handle_command, 3752 concat ("Specify how to handle a signal.\n\ 3753Args are signals and actions to apply to those signals.\n\ 3754Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\ 3755from 1-15 are allowed for compatibility with old versions of GDB.\n\ 3756Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\ 3757The special arg \"all\" is recognized to mean all signals except those\n\ 3758used by the debugger, typically SIGTRAP and SIGINT.\n", "Recognized actions include \"stop\", \"nostop\", \"print\", \"noprint\",\n\ 3759\"pass\", \"nopass\", \"ignore\", or \"noignore\".\n\ 3760Stop means reenter debugger if this signal happens (implies print).\n\ 3761Print means print a message if this signal happens.\n\ 3762Pass means let program see this signal; otherwise program doesn't know.\n\ 3763Ignore is a synonym for nopass and noignore is a synonym for pass.\n\ 3764Pass and Stop may be combined.", NULL)); 3765 if (xdb_commands) 3766 { 3767 add_com ("lz", class_info, signals_info, 3768 "What debugger does when program gets various signals.\n\ 3769Specify a signal as argument to print info on that signal only."); 3770 add_com ("z", class_run, xdb_handle_command, 3771 concat ("Specify how to handle a signal.\n\ 3772Args are signals and actions to apply to those signals.\n\ 3773Symbolic signals (e.g. SIGSEGV) are recommended but numeric signals\n\ 3774from 1-15 are allowed for compatibility with old versions of GDB.\n\ 3775Numeric ranges may be specified with the form LOW-HIGH (e.g. 1-5).\n\ 3776The special arg \"all\" is recognized to mean all signals except those\n\ 3777used by the debugger, typically SIGTRAP and SIGINT.\n", "Recognized actions include \"s\" (toggles between stop and nostop), \n\ 3778\"r\" (toggles between print and noprint), \"i\" (toggles between pass and \ 3779nopass), \"Q\" (noprint)\n\ 3780Stop means reenter debugger if this signal happens (implies print).\n\ 3781Print means print a message if this signal happens.\n\ 3782Pass means let program see this signal; otherwise program doesn't know.\n\ 3783Ignore is a synonym for nopass and noignore is a synonym for pass.\n\ 3784Pass and Stop may be combined.", NULL)); 3785 } 3786 3787 if (!dbx_commands) 3788 stop_command = 3789 add_cmd ("stop", class_obscure, not_just_help_class_command, "There is no `stop' command, but you can set a hook on `stop'.\n\ 3790This allows you to set a list of commands to be run each time execution\n\ 3791of the program stops.", &cmdlist); 3792 3793 numsigs = (int) TARGET_SIGNAL_LAST; 3794 signal_stop = (unsigned char *) xmalloc (sizeof (signal_stop[0]) * numsigs); 3795 signal_print = (unsigned char *) 3796 xmalloc (sizeof (signal_print[0]) * numsigs); 3797 signal_program = (unsigned char *) 3798 xmalloc (sizeof (signal_program[0]) * numsigs); 3799 for (i = 0; i < numsigs; i++) 3800 { 3801 signal_stop[i] = 1; 3802 signal_print[i] = 1; 3803 signal_program[i] = 1; 3804 } 3805 3806 /* Signals caused by debugger's own actions 3807 should not be given to the program afterwards. */ 3808 signal_program[TARGET_SIGNAL_TRAP] = 0; 3809 signal_program[TARGET_SIGNAL_INT] = 0; 3810 3811 /* Signals that are not errors should not normally enter the debugger. */ 3812 signal_stop[TARGET_SIGNAL_ALRM] = 0; 3813 signal_print[TARGET_SIGNAL_ALRM] = 0; 3814 signal_stop[TARGET_SIGNAL_VTALRM] = 0; 3815 signal_print[TARGET_SIGNAL_VTALRM] = 0; 3816 signal_stop[TARGET_SIGNAL_PROF] = 0; 3817 signal_print[TARGET_SIGNAL_PROF] = 0; 3818 signal_stop[TARGET_SIGNAL_CHLD] = 0; 3819 signal_print[TARGET_SIGNAL_CHLD] = 0; 3820 signal_stop[TARGET_SIGNAL_IO] = 0; 3821 signal_print[TARGET_SIGNAL_IO] = 0; 3822 signal_stop[TARGET_SIGNAL_POLL] = 0; 3823 signal_print[TARGET_SIGNAL_POLL] = 0; 3824 signal_stop[TARGET_SIGNAL_URG] = 0; 3825 signal_print[TARGET_SIGNAL_URG] = 0; 3826 signal_stop[TARGET_SIGNAL_WINCH] = 0; 3827 signal_print[TARGET_SIGNAL_WINCH] = 0; 3828 3829 /* These signals are used internally by user-level thread 3830 implementations. (See signal(5) on Solaris.) Like the above 3831 signals, a healthy program receives and handles them as part of 3832 its normal operation. */ 3833 signal_stop[TARGET_SIGNAL_LWP] = 0; 3834 signal_print[TARGET_SIGNAL_LWP] = 0; 3835 signal_stop[TARGET_SIGNAL_WAITING] = 0; 3836 signal_print[TARGET_SIGNAL_WAITING] = 0; 3837 signal_stop[TARGET_SIGNAL_CANCEL] = 0; 3838 signal_print[TARGET_SIGNAL_CANCEL] = 0; 3839 3840#ifdef SOLIB_ADD 3841 deprecated_add_show_from_set 3842 (add_set_cmd ("stop-on-solib-events", class_support, var_zinteger, 3843 (char *) &stop_on_solib_events, 3844 "Set stopping for shared library events.\n\ 3845If nonzero, gdb will give control to the user when the dynamic linker\n\ 3846notifies gdb of shared library events. The most common event of interest\n\ 3847to the user would be loading/unloading of a new library.\n", &setlist), &showlist); 3848#endif 3849 3850 c = add_set_enum_cmd ("follow-fork-mode", 3851 class_run, 3852 follow_fork_mode_kind_names, &follow_fork_mode_string, 3853 "Set debugger response to a program call of fork \ 3854or vfork.\n\ 3855A fork or vfork creates a new process. follow-fork-mode can be:\n\ 3856 parent - the original process is debugged after a fork\n\ 3857 child - the new process is debugged after a fork\n\ 3858The unfollowed process will continue to run.\n\ 3859By default, the debugger will follow the parent process.", &setlist); 3860 deprecated_add_show_from_set (c, &showlist); 3861 3862 c = add_set_enum_cmd ("scheduler-locking", class_run, scheduler_enums, /* array of string names */ 3863 &scheduler_mode, /* current mode */ 3864 "Set mode for locking scheduler during execution.\n\ 3865off == no locking (threads may preempt at any time)\n\ 3866on == full locking (no thread except the current thread may run)\n\ 3867step == scheduler locked during every single-step operation.\n\ 3868 In this mode, no other thread may run during a step command.\n\ 3869 Other threads may run while stepping over a function call ('next').", &setlist); 3870 3871 set_cmd_sfunc (c, set_schedlock_func); /* traps on target vector */ 3872 deprecated_add_show_from_set (c, &showlist); 3873 3874 c = add_set_cmd ("step-mode", class_run, 3875 var_boolean, (char *) &step_stop_if_no_debug, 3876 "Set mode of the step operation. When set, doing a step over a\n\ 3877function without debug line information will stop at the first\n\ 3878instruction of that function. Otherwise, the function is skipped and\n\ 3879the step command stops at a different source line.", &setlist); 3880 deprecated_add_show_from_set (c, &showlist); 3881 3882 /* ptid initializations */ 3883 null_ptid = ptid_build (0, 0, 0); 3884 minus_one_ptid = ptid_build (-1, 0, 0); 3885 inferior_ptid = null_ptid; 3886 target_last_wait_ptid = minus_one_ptid; 3887} 3888