Lines Matching refs:ecs
121 struct execution_control_state *ecs);
2146 static void keep_going_pass_signal (struct execution_control_state *ecs);
2147 static void prepare_to_wait (struct execution_control_state *ecs);
2268 execution_control_state ecs (tp);
2269 keep_going_pass_signal (&ecs);
2271 if (!ecs.wait_some_more)
3588 execution_control_state ecs (tp);
3590 keep_going_pass_signal (&ecs);
3591 if (!ecs.wait_some_more)
3863 static void handle_inferior_event (struct execution_control_state *ecs);
3866 struct execution_control_state *ecs);
3868 struct execution_control_state *ecs);
3869 ecs);
3873 static void end_stepping_range (struct execution_control_state *ecs);
3874 static void stop_waiting (struct execution_control_state *ecs);
3875 static void keep_going (struct execution_control_state *ecs);
3876 static void process_event_stop_test (struct execution_control_state *ecs);
3877 static bool switch_back_to_stepped_thread (struct execution_control_state *ecs);
4158 do_target_wait (ptid_t wait_ptid, execution_control_state *ecs,
4183 ecs->ws.set_ignore ();
4212 ecs->ptid = do_target_wait_1 (inf, wait_ptid, &ecs->ws, options);
4213 ecs->target = inf->process_target ();
4214 return (ecs->ws.kind () != TARGET_WAITKIND_IGNORE);
4245 ecs->ws.set_ignore ();
4264 static int finish_step_over (struct execution_control_state *ecs);
4395 execution_control_state ecs;
4405 ecs.ptid = do_target_wait_1 (inf, minus_one_ptid, &ecs.ws, 0);
4406 ecs.target = inf->process_target ();
4409 print_target_wait_results (minus_one_ptid, ecs.ptid, ecs.ws);
4412 handle_inferior_event (&ecs);
4414 if (!ecs.wait_some_more)
4462 clean_up_just_stopped_threads_fsms (struct execution_control_state *ecs)
4466 if (ecs->event_thread != nullptr)
4467 gdb_assert (ecs->event_thread == inferior_thread ());
4469 if (ecs->event_thread != nullptr
4470 && ecs->event_thread->thread_fsm () != nullptr)
4471 ecs->event_thread->thread_fsm ()->clean_up (ecs->event_thread);
4482 if (thr == ecs->event_thread)
4597 execution_control_state ecs;
4672 if (!do_target_wait (waiton_ptid, &ecs, TARGET_WNOHANG))
4679 gdb_assert (ecs.ws.kind () != TARGET_WAITKIND_IGNORE);
4683 if (ecs.ptid != null_ptid
4684 && ecs.ptid != minus_one_ptid)
4685 switch_to_inferior_no_thread (find_inferior_ptid (ecs.target, ecs.ptid));
4687 switch_to_target_no_thread (ecs.target);
4690 print_target_wait_results (minus_one_ptid, ecs.ptid, ecs.ws);
4695 ptid_t finish_ptid = !target_is_non_stop_p () ? minus_one_ptid : ecs.ptid;
4696 scoped_finish_thread_state finish_state (ecs.target, finish_ptid);
4708 handle_inferior_event (&ecs);
4710 if (!ecs.wait_some_more)
4712 struct inferior *inf = find_inferior_ptid (ecs.target, ecs.ptid);
4714 struct thread_info *thr = ecs.event_thread;
4723 keep_going (&ecs);
4733 if (ecs.event_thread == nullptr
4734 || !ecs.event_thread->control.in_cond_eval)
4737 clean_up_just_stopped_threads_fsms (&ecs);
4778 && ecs.ws.kind () != TARGET_WAITKIND_NO_RESUMED)
4892 context_switch (execution_control_state *ecs)
4894 if (ecs->ptid != inferior_ptid
4896 || ecs->event_thread != inferior_thread ()))
4900 ecs->ptid.to_string ().c_str ());
4903 switch_to_thread (ecs->event_thread);
5116 handle_stop_requested (struct execution_control_state *ecs)
5118 if (ecs->event_thread->stop_requested)
5120 ecs->ws.set_stopped (GDB_SIGNAL_0);
5121 handle_signal_stop (ecs);
5133 handle_syscall_event (struct execution_control_state *ecs)
5138 context_switch (ecs);
5140 regcache = get_thread_regcache (ecs->event_thread);
5141 syscall_number = ecs->ws.syscall_number ();
5142 ecs->event_thread->set_stop_pc (regcache_read_pc (regcache));
5149 ecs->event_thread->control.stop_bpstat
5150 = bpstat_stop_status_nowatch (ecs->event_thread->inf->aspace.get (),
5151 ecs->event_thread->stop_pc (),
5152 ecs->event_thread, ecs->ws);
5154 if (handle_stop_requested (ecs))
5157 if (bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
5164 if (handle_stop_requested (ecs))
5168 keep_going (ecs);
5177 struct execution_control_state *ecs)
5179 if (!ecs->stop_func_filled_in)
5186 find_pc_partial_function_sym (ecs->event_thread->stop_pc (),
5188 &ecs->stop_func_start,
5189 &ecs->stop_func_end,
5191 ecs->stop_func_name = gsi == nullptr ? nullptr : gsi->print_name ();
5202 && ecs->stop_func_start <= block->entry_pc ()
5203 && block->entry_pc () < ecs->stop_func_end)
5205 ecs->stop_func_start
5211 ecs->stop_func_alt_start = ecs->stop_func_start;
5214 ecs->stop_func_start
5215 = gdbarch_skip_entrypoint (gdbarch, ecs->stop_func_start);
5218 ecs->stop_func_filled_in = 1;
5223 /* Return the STOP_SOON field of the inferior pointed at by ECS. */
5226 get_inferior_stop_soon (execution_control_state *ecs)
5228 struct inferior *inf = find_inferior_ptid (ecs->target, ecs->ptid);
5794 handle_no_resumed (struct execution_control_state *ecs)
5815 prepare_to_wait (ecs);
5911 prepare_to_wait (ecs);
5924 handle_thread_exited (execution_control_state *ecs)
5926 context_switch (ecs);
5930 ecs->event_thread->stepping_over_breakpoint = 0;
5931 ecs->event_thread->stepping_over_watchpoint = 0;
5938 bool abort_cmd = (ecs->event_thread->thread_fsm () != nullptr);
5945 set_thread_exited (ecs->event_thread);
5952 int ret = finish_step_over (ecs);
5954 /* finish_step_over returns true if it moves ecs' wait status
5965 switch_to_thread (ecs->event_thread);
5966 ecs->event_thread = nullptr;
5974 delete_thread (ecs->event_thread);
5985 clear_proceed_status_thread (ecs->event_thread);
5986 if (switch_back_to_stepped_thread (ecs))
5988 delete_thread (ecs->event_thread);
5992 inferior *inf = ecs->event_thread->inf;
5993 bool slock_applies = schedlock_applies (ecs->event_thread);
5995 delete_thread (ecs->event_thread);
5996 ecs->event_thread = nullptr;
6000 auto handle_as_no_resumed = [ecs] ()
6004 ecs->ws.set_no_resumed ();
6005 ecs->event_thread = nullptr;
6006 ecs->ptid = minus_one_ptid;
6009 set_last_target_status (ecs->target, ecs->ptid, ecs->ws);
6011 return handle_no_resumed (ecs);
6058 prepare_to_wait (ecs);
6072 ecs->event_thread->stepping_over_breakpoint to 1 to single step
6076 handle_inferior_event (struct execution_control_state *ecs)
6083 infrun_debug_printf ("%s", ecs->ws.to_string ().c_str ());
6085 if (ecs->ws.kind () == TARGET_WAITKIND_IGNORE)
6096 prepare_to_wait (ecs);
6100 if (ecs->ws.kind () == TARGET_WAITKIND_NO_RESUMED
6101 && handle_no_resumed (ecs))
6105 set_last_target_status (ecs->target, ecs->ptid, ecs->ws);
6110 if (ecs->ws.kind () == TARGET_WAITKIND_NO_RESUMED)
6114 stop_waiting (ecs);
6118 if (ecs->ws.kind () != TARGET_WAITKIND_EXITED
6119 && ecs->ws.kind () != TARGET_WAITKIND_SIGNALLED)
6121 ecs->event_thread = ecs->target->find_thread (ecs->ptid);
6123 if (ecs->event_thread == nullptr)
6124 ecs->event_thread = add_thread (ecs->target, ecs->ptid);
6128 ecs->event_thread->control.may_range_step = 0;
6131 /* Dependent on valid ECS->EVENT_THREAD. */
6132 adjust_pc_after_break (ecs->event_thread, ecs->ws);
6149 if (ecs->ws.kind () == TARGET_WAITKIND_STOPPED
6150 && (ecs->ws.sig () == GDB_SIGNAL_ILL
6151 || ecs->ws.sig () == GDB_SIGNAL_SEGV
6152 || ecs->ws.sig () == GDB_SIGNAL_EMT))
6154 struct regcache *regcache = get_thread_regcache (ecs->event_thread);
6156 if (breakpoint_inserted_here_p (ecs->event_thread->inf->aspace.get (),
6160 ecs->ws.set_stopped (GDB_SIGNAL_TRAP);
6164 mark_non_executing_threads (ecs->target, ecs->ptid, ecs->ws);
6166 switch (ecs->ws.kind ())
6170 context_switch (ecs);
6178 stop_kind stop_soon = get_inferior_stop_soon (ecs);
6183 regcache = get_thread_regcache (ecs->event_thread);
6187 ecs->event_thread->set_stop_pc (regcache_read_pc (regcache));
6188 address_space *aspace = ecs->event_thread->inf->aspace.get ();
6189 ecs->event_thread->control.stop_bpstat
6191 ecs->event_thread->stop_pc (),
6192 ecs->event_thread, ecs->ws);
6194 if (handle_stop_requested (ecs))
6197 if (bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
6200 process_event_stop_test (ecs);
6208 ecs->event_thread->set_stop_signal (GDB_SIGNAL_0);
6215 stop_waiting (ecs);
6230 prepare_to_wait (ecs);
6240 stop_waiting (ecs);
6248 if (handle_stop_requested (ecs))
6250 context_switch (ecs);
6252 prepare_to_wait (ecs);
6256 if (handle_stop_requested (ecs))
6258 context_switch (ecs);
6259 if (!switch_back_to_stepped_thread (ecs))
6260 keep_going (ecs);
6264 if (handle_thread_exited (ecs))
6266 stop_waiting (ecs);
6272 /* Depending on the system, ecs->ptid may point to a thread or
6277 thread_info *thr = ecs->target->find_thread (ecs->ptid);
6282 inferior *inf = find_inferior_ptid (ecs->target, ecs->ptid);
6292 if (ecs->ws.kind () == TARGET_WAITKIND_EXITED)
6297 (LONGEST) ecs->ws.exit_status ());
6301 current_inferior ()->exit_code = (LONGEST) ecs->ws.exit_status ();
6304 return_child_result_value = ecs->ws.exit_status ();
6306 interps_notify_exited (ecs->ws.exit_status ());
6318 ecs->ws.sig ()));
6333 interps_notify_signal_exited (ecs->ws.sig ());
6339 stop_waiting (ecs);
6346 displaced_step_finish (ecs->event_thread, ecs->ws);
6352 context_switch (ecs);
6366 if (ecs->ws.kind () == TARGET_WAITKIND_FORKED)
6370 detach_breakpoints (ecs->ws.child_ptid ());
6378 ecs->event_thread->pending_follow = ecs->ws;
6380 ecs->event_thread->set_stop_pc
6381 (regcache_read_pc (get_thread_regcache (ecs->event_thread)));
6383 ecs->event_thread->control.stop_bpstat
6384 = bpstat_stop_status_nowatch (ecs->event_thread->inf->aspace.get (),
6385 ecs->event_thread->stop_pc (),
6386 ecs->event_thread, ecs->ws);
6388 if (handle_stop_requested (ecs))
6395 if (!bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
6398 = (ecs->ws.kind () != TARGET_WAITKIND_THREAD_CLONED
6401 ecs->event_thread->set_stop_signal (GDB_SIGNAL_0);
6404 = ecs->event_thread->inf->process_target ();
6407 if (ecs->ws.kind () != TARGET_WAITKIND_THREAD_CLONED)
6412 inferior *inf = ecs->event_thread->inf;
6413 inf->top_target ()->follow_clone (ecs->ws.child_ptid ());
6414 ecs->event_thread->pending_follow.set_spurious ();
6419 thread_info *parent = ecs->event_thread;
6420 thread_info *child = targ->find_thread (ecs->ws.child_ptid ());
6426 if (ecs->ws.kind () != TARGET_WAITKIND_THREAD_CLONED
6431 if ((ecs->ws.kind () == TARGET_WAITKIND_THREAD_CLONED
6432 && !schedlock_applies (ecs->event_thread))
6433 || (ecs->ws.kind () != TARGET_WAITKIND_THREAD_CLONED
6439 if ((ecs->ws.kind () == TARGET_WAITKIND_THREAD_CLONED
6441 && !schedlock_applies (ecs->event_thread))
6442 || (ecs->ws.kind () != TARGET_WAITKIND_THREAD_CLONED
6452 ecs->event_thread = inferior_thread ();
6453 ecs->ptid = inferior_ptid;
6454 keep_going (ecs);
6462 ecs->event_thread = inferior_thread ();
6463 ecs->ptid = inferior_ptid;
6475 || !switch_back_to_stepped_thread (ecs))
6476 keep_going (ecs);
6479 stop_waiting (ecs);
6482 process_event_stop_test (ecs);
6489 context_switch (ecs);
6491 handle_vfork_done (ecs->event_thread);
6492 gdb_assert (inferior_thread () == ecs->event_thread);
6494 if (handle_stop_requested (ecs))
6497 if (!switch_back_to_stepped_thread (ecs))
6499 gdb_assert (inferior_thread () == ecs->event_thread);
6502 keep_going (ecs);
6511 switch_to_thread_no_regs (ecs->event_thread);
6519 follow_exec (inferior_ptid, ecs->ws.execd_pathname ());
6524 ecs->event_thread = inferior_thread ();
6526 ecs->event_thread->set_stop_pc
6527 (regcache_read_pc (get_thread_regcache (ecs->event_thread)));
6529 ecs->event_thread->control.stop_bpstat
6530 = bpstat_stop_status_nowatch (ecs->event_thread->inf->aspace.get (),
6531 ecs->event_thread->stop_pc (),
6532 ecs->event_thread, ecs->ws);
6534 if (handle_stop_requested (ecs))
6538 if (!bpstat_causes_stop (ecs->event_thread->control.stop_bpstat))
6540 ecs->event_thread->set_stop_signal (GDB_SIGNAL_0);
6541 keep_going (ecs);
6544 process_event_stop_test (ecs);
6551 if (handle_syscall_event (ecs) == 0)
6552 process_event_stop_test (ecs);
6561 if (handle_syscall_event (ecs) == 0)
6562 process_event_stop_test (ecs);
6566 handle_signal_stop (ecs);
6573 context_switch (ecs);
6577 ecs->event_thread->set_stop_pc
6580 if (handle_stop_requested (ecs))
6584 stop_waiting (ecs);
6682 execution_control_state ecs (tp);
6684 keep_going_pass_signal (&ecs);
6706 finish_step_over (struct execution_control_state *ecs)
6708 displaced_step_finish (ecs->event_thread, ecs->ws);
6717 gdb_assert (ecs->event_thread->control.trap_expected);
6719 update_thread_events_after_step_over (ecs->event_thread, ecs->ws);
6747 context_switch (ecs);
6750 restart_threads (ecs->event_thread);
6762 if (ecs->event_thread->stepping_over_watchpoint)
6769 if (ecs->ws.kind () == TARGET_WAITKIND_THREAD_EXITED)
6776 struct thread_info *tp = ecs->event_thread;
6785 save_waitstatus (tp, ecs->ws);
6811 prepare_to_wait (ecs);
6848 handle_signal_stop (struct execution_control_state *ecs)
6856 gdb_assert (ecs->ws.kind () == TARGET_WAITKIND_STOPPED);
6858 ecs->event_thread->set_stop_signal (ecs->ws.sig ());
6863 if (finish_step_over (ecs))
6869 if (ecs->event_thread->stop_requested
6870 && ecs->event_thread->stop_signal () == GDB_SIGNAL_TRAP)
6871 ecs->event_thread->set_stop_signal (GDB_SIGNAL_0);
6873 ecs->event_thread->set_stop_pc
6874 (regcache_read_pc (get_thread_regcache (ecs->event_thread)));
6876 context_switch (ecs);
6879 deprecated_context_hook (ecs->event_thread->global_num);
6883 struct regcache *regcache = get_thread_regcache (ecs->event_thread);
6887 ("stop_pc=%s", paddress (reg_gdbarch, ecs->event_thread->stop_pc ()));
6905 stop_soon = get_inferior_stop_soon (ecs);
6910 stop_waiting (ecs);
6935 && (ecs->event_thread->stop_signal () == GDB_SIGNAL_STOP
6936 || ecs->event_thread->stop_signal () == GDB_SIGNAL_TRAP
6937 || ecs->event_thread->stop_signal () == GDB_SIGNAL_0))
6940 stop_waiting (ecs);
6941 ecs->event_thread->set_stop_signal (GDB_SIGNAL_0);
6950 if (ecs->event_thread->stop_signal () == GDB_SIGNAL_TRAP)
6955 regcache = get_thread_regcache (ecs->event_thread);
6956 const address_space *aspace = ecs->event_thread->inf->aspace.get ();
6963 if (!thread_has_single_step_breakpoint_here (ecs->event_thread,
6970 ecs->ptid.to_string ().c_str ());
6971 ecs->hit_singlestep_breakpoint = 1;
6977 ecs->ptid.to_string ().c_str ());
6982 if (ecs->event_thread->stop_signal () == GDB_SIGNAL_TRAP
6983 && ecs->event_thread->control.trap_expected
6984 && ecs->event_thread->stepping_over_watchpoint)
6987 stopped_by_watchpoint = watchpoints_triggered (ecs->ws);
7022 ecs->event_thread->stepping_over_watchpoint = 1;
7023 keep_going (ecs);
7027 ecs->event_thread->stepping_over_breakpoint = 0;
7028 ecs->event_thread->stepping_over_watchpoint = 0;
7029 bpstat_clear (&ecs->event_thread->control.stop_bpstat);
7030 ecs->event_thread->control.stop_step = 0;
7038 if (ecs->event_thread->control.step_range_end != 1)
7040 const address_space *aspace = ecs->event_thread->inf->aspace.get ();
7058 ecs->event_thread->stop_pc (),
7059 ecs->ws)
7060 && !(ecs->event_thread->stop_signal () == GDB_SIGNAL_TRAP
7061 && ecs->event_thread->control.trap_expected
7063 ecs->event_thread->prev_pc,
7064 ecs->ws)))
7067 ecs->event_thread->stop_pc (),
7068 ecs->ws);
7069 skip_inline_frames (ecs->event_thread, stop_chain);
7073 if (ecs->event_thread->stop_signal () == GDB_SIGNAL_TRAP
7074 && ecs->event_thread->control.trap_expected
7076 && currently_stepping (ecs->event_thread))
7089 if (ecs->event_thread->control.step_range_end == 0
7094 ecs->event_thread->stepping_over_breakpoint = 1;
7095 keep_going (ecs);
7104 ecs->stepping_over_breakpoint, making sure we
7106 ecs->event_thread->stepping_over_breakpoint = 1;
7112 ecs->event_thread->control.stop_bpstat
7113 = bpstat_stop_status (ecs->event_thread->inf->aspace.get (),
7114 ecs->event_thread->stop_pc (),
7115 ecs->event_thread, ecs->ws, stop_chain);
7129 if (ecs->event_thread->stop_signal () == GDB_SIGNAL_TRAP
7130 && !bpstat_explains_signal (ecs->event_thread->control.stop_bpstat,
7160 = !bpstat_explains_signal (ecs->event_thread->control.stop_bpstat,
7161 ecs->event_thread->stop_signal ());
7168 ecs->event_thread->stop_pc ()))
7175 regcache = get_thread_regcache (ecs->event_thread);
7187 ecs->event_thread->stop_pc () + decr_pc);
7210 random_signal = !(ecs->event_thread->stop_signal () == GDB_SIGNAL_TRAP
7211 && currently_stepping (ecs->event_thread));
7217 random_signal = !ecs->hit_singlestep_breakpoint;
7225 if (ecs->event_thread->stop_requested)
7237 enum gdb_signal stop_signal = ecs->event_thread->stop_signal ();
7248 || ecs->event_thread->stop_requested
7249 || signal_stop_state (ecs->event_thread->stop_signal ()))
7251 stop_waiting (ecs);
7258 if (signal_print[ecs->event_thread->stop_signal ()])
7262 notify_signal_received (ecs->event_thread->stop_signal ());
7267 if (signal_program[ecs->event_thread->stop_signal ()] == 0)
7268 ecs->event_thread->set_stop_signal (GDB_SIGNAL_0);
7270 if (ecs->event_thread->prev_pc == ecs->event_thread->stop_pc ()
7271 && ecs->event_thread->control.trap_expected
7272 && ecs->event_thread->control.step_resume_breakpoint == nullptr)
7287 ecs->event_thread->step_after_step_resume_breakpoint = 1;
7289 ecs->event_thread->control.trap_expected = 0;
7293 if (!switch_back_to_stepped_thread (ecs))
7294 keep_going (ecs);
7298 if (ecs->event_thread->stop_signal () != GDB_SIGNAL_0
7299 && (pc_in_thread_step_range (ecs->event_thread->stop_pc (),
7300 ecs->event_thread)
7301 || ecs->event_thread->control.step_range_end == 1)
7303 == ecs->event_thread->control.step_stack_frame_id)
7304 && ecs->event_thread->control.step_resume_breakpoint == nullptr)
7319 ecs->event_thread->step_after_step_resume_breakpoint = 1;
7321 ecs->event_thread->control.trap_expected = 0;
7322 keep_going (ecs);
7333 if (!switch_back_to_stepped_thread (ecs))
7337 keep_going (ecs);
7342 process_event_stop_test (ecs);
7348 update_line_range_start (CORE_ADDR pc, struct execution_control_state *ecs)
7353 CORE_ADDR start_line_pc = ecs->event_thread->control.step_range_start;
7404 process_event_stop_test (struct execution_control_state *ecs)
7417 what = bpstat_what (ecs->event_thread->control.stop_bpstat);
7426 bpstat_run_callbacks (ecs->event_thread->control.stop_bpstat);
7430 = ecs->event_thread->control.step_frame_id;
7443 ecs->event_thread->stepping_over_breakpoint = 1;
7464 keep_going (ecs);
7472 check_exception_resume (ecs, frame);
7473 keep_going (ecs);
7500 gdb_assert (ecs->event_thread->control.exception_resume_breakpoint
7502 delete_exception_resume_breakpoint (ecs->event_thread);
7506 check_longjmp_breakpoint_for_call_dummy (ecs->event_thread);
7508 if (!frame_id_p (ecs->event_thread->initiating_frame))
7511 keep_going (ecs);
7516 init_frame = frame_find_by_id (ecs->event_thread->initiating_frame);
7520 if (*curr_frame_id == ecs->event_thread->initiating_frame)
7527 keep_going (ecs);
7534 delete_step_resume_breakpoint (ecs->event_thread);
7536 end_stepping_range (ecs);
7542 ecs->event_thread->stepping_over_breakpoint = 1;
7550 delete_step_resume_breakpoint (ecs->event_thread);
7551 if (ecs->event_thread->control.proceed_to_finish
7554 struct thread_info *tp = ecs->event_thread;
7562 keep_going (ecs);
7565 fill_in_stop_func (gdbarch, ecs);
7566 if (ecs->event_thread->stop_pc () == ecs->stop_func_start
7573 ecs->event_thread->stepping_over_breakpoint = 1;
7574 keep_going (ecs);
7586 ecs->event_thread->stepping_over_breakpoint = 1;
7588 stop_waiting (ecs);
7598 ecs->event_thread->stepping_over_breakpoint = 1;
7599 stop_waiting (ecs);
7605 delete_step_resume_breakpoint (ecs->event_thread);
7606 if (ecs->event_thread->step_after_step_resume_breakpoint)
7611 ecs->event_thread->step_after_step_resume_breakpoint = 0;
7612 ecs->event_thread->stepping_over_breakpoint = 1;
7613 keep_going (ecs);
7628 if (ecs->event_thread->stepped_breakpoint)
7631 = ecs->event_thread->control.step_resume_breakpoint;
7636 && sr_bp->first_loc ().address == ecs->event_thread->prev_pc)
7639 delete_step_resume_breakpoint (ecs->event_thread);
7640 ecs->event_thread->step_after_step_resume_breakpoint = 0;
7651 if (switch_back_to_stepped_thread (ecs))
7654 if (ecs->event_thread->control.step_resume_breakpoint)
7661 keep_going (ecs);
7665 if (ecs->event_thread->control.step_range_end == 0)
7669 keep_going (ecs);
7673 fill_in_stop_func (gdbarch, ecs);
7685 if (pc_in_thread_step_range (ecs->event_thread->stop_pc (),
7686 ecs->event_thread)
7692 paddress (gdbarch, ecs->event_thread->control.step_range_start),
7693 paddress (gdbarch, ecs->event_thread->control.step_range_end));
7698 ecs->event_thread->control.may_range_step = 1;
7703 CORE_ADDR stop_pc = ecs->event_thread->stop_pc ();
7704 if (stop_pc == ecs->event_thread->control.step_range_start
7705 && stop_pc != ecs->stop_func_start
7707 end_stepping_range (ecs);
7709 keep_going (ecs);
7729 && ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
7730 && in_solib_dynsym_resolve_code (ecs->event_thread->stop_pc ())
7731 && (ecs->event_thread->control.step_start_function == nullptr
7733 ecs->event_thread->control.step_start_function->value_block ()
7737 gdbarch_skip_solib_resolver (gdbarch, ecs->event_thread->stop_pc ());
7753 keep_going (ecs);
7758 if (ecs->event_thread->control.step_over_calls != STEP_OVER_NONE
7760 ecs->event_thread->stop_pc ()))
7763 keep_going (ecs);
7767 if (ecs->event_thread->control.step_range_end != 1
7768 && (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
7769 || ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
7778 keep_going (ecs);
7788 ecs->event_thread->stop_pc (),
7789 ecs->stop_func_name)
7790 && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE)
7793 CORE_ADDR stop_pc = ecs->event_thread->stop_pc ();
7816 keep_going (ecs);
7851 != ecs->event_thread->control.step_stack_frame_id)
7854 == ecs->event_thread->control.step_stack_frame_id)
7855 && ((ecs->event_thread->control.step_stack_frame_id
7857 || (ecs->event_thread->control.step_start_function
7858 != find_pc_function (ecs->event_thread->stop_pc ())))))
7860 CORE_ADDR stop_pc = ecs->event_thread->stop_pc ();
7865 if (ecs->event_thread->control.step_over_calls == STEP_OVER_NONE)
7871 end_stepping_range (ecs);
7878 && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE
7880 || (ecs->stop_func_start == 0
7888 keep_going (ecs);
7892 if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL)
7912 if (ecs->stop_func_start != stop_pc && ecs->stop_func_start != 0)
7916 sr_sal.pc = ecs->stop_func_start;
7925 keep_going (ecs);
7938 ecs->stop_func_start = real_stop_pc;
7943 sr_sal.pc = ecs->stop_func_start;
7948 keep_going (ecs);
7962 tmp_sal = find_pc_line (ecs->stop_func_start, 0);
7964 && !function_name_is_marked_for_skip (ecs->stop_func_name,
7966 && !inline_frame_is_marked_for_skip (true, ecs->event_thread))
7969 handle_step_into_function_backward (gdbarch, ecs);
7971 handle_step_into_function (gdbarch, ecs);
7979 if (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
7982 end_stepping_range (ecs);
7993 if (ecs->stop_func_start != stop_pc)
7998 sr_sal.pc = ecs->stop_func_start;
8009 keep_going (ecs);
8016 && ecs->event_thread->control.step_over_calls != STEP_OVER_NONE)
8018 CORE_ADDR stop_pc = ecs->event_thread->stop_pc ();
8021 || (ecs->stop_func_start == 0
8029 keep_going (ecs);
8038 sr_sal.pc = ecs->stop_func_start;
8042 keep_going (ecs);
8051 stop_pc_sal = find_pc_line (ecs->event_thread->stop_pc (), 0);
8056 if (ecs->event_thread->control.step_over_calls == STEP_OVER_UNDEBUGGABLE
8057 && ecs->stop_func_name == nullptr
8076 end_stepping_range (ecs);
8084 keep_going (ecs);
8090 && ecs->event_thread->control.proceed_to_finish
8091 && ecs->event_thread->stop_pc () >= ecs->stop_func_alt_start
8092 && ecs->event_thread->stop_pc () < ecs->stop_func_start)
8100 ecs->event_thread->control.step_range_start
8101 = ecs->event_thread->control.step_range_end = 1;
8102 keep_going (ecs);
8107 if (ecs->event_thread->control.step_range_end == 1)
8112 end_stepping_range (ecs);
8123 end_stepping_range (ecs);
8134 == ecs->event_thread->control.step_stack_frame_id
8135 && inline_skipped_frames (ecs->event_thread) > 0
8136 && ecs->event_thread->control.step_frame_id.artificial_depth > 0
8137 && ecs->event_thread->control.step_frame_id.code_addr_p)
8141 = block_for_pc (ecs->event_thread->control.step_frame_id.code_addr);
8142 const struct block *curr = block_for_pc (ecs->event_thread->stop_pc ());
8151 while (inline_skipped_frames (ecs->event_thread) > depth)
8152 step_into_inline_frame (ecs->event_thread);
8160 && inline_skipped_frames (ecs->event_thread))
8166 if (ecs->event_thread->control.step_over_calls != STEP_OVER_ALL)
8173 if (call_sal.line == ecs->event_thread->current_line
8174 && call_sal.symtab == ecs->event_thread->current_symtab)
8176 step_into_inline_frame (ecs->event_thread);
8177 if (inline_frame_is_marked_for_skip (false, ecs->event_thread))
8179 keep_going (ecs);
8184 end_stepping_range (ecs);
8192 if (call_sal.line == ecs->event_thread->current_line
8193 && call_sal.symtab == ecs->event_thread->current_symtab)
8194 keep_going (ecs);
8196 end_stepping_range (ecs);
8212 if (ecs->event_thread->control.step_over_calls == STEP_OVER_ALL
8213 || inline_frame_is_marked_for_skip (false, ecs->event_thread))
8214 keep_going (ecs);
8216 end_stepping_range (ecs);
8221 if ((ecs->event_thread->stop_pc () == stop_pc_sal.pc)
8222 && (ecs->event_thread->current_line != stop_pc_sal.line
8223 || ecs->event_thread->current_symtab != stop_pc_sal.symtab))
8233 CORE_ADDR stop_pc = ecs->event_thread->stop_pc ();
8235 = update_line_range_start (stop_pc, ecs);
8243 ecs->event_thread->control.step_range_start
8245 ecs->event_thread->control.step_range_end = stop_pc;
8246 set_step_info (ecs->event_thread, frame, stop_pc_sal);
8247 keep_going (ecs);
8258 end_stepping_range (ecs);
8315 ecs->event_thread->control.step_range_start = stop_pc_sal.pc;
8316 ecs->event_thread->control.step_range_end = stop_pc_sal.end;
8317 ecs->event_thread->control.may_range_step = 1;
8320 paddress (gdbarch, ecs->event_thread->control.step_range_start),
8321 paddress (gdbarch, ecs->event_thread->control.step_range_end),
8322 ecs->event_thread->control.may_range_step);
8324 set_step_info (ecs->event_thread, frame, stop_pc_sal);
8330 CORE_ADDR stop_pc = ecs->event_thread->stop_pc ();
8333 if (stop_pc != ecs->event_thread->control.step_range_start)
8334 ecs->event_thread->control.step_range_start
8335 = update_line_range_start (stop_pc, ecs);
8338 keep_going (ecs);
8350 switch_back_to_stepped_thread (struct execution_control_state *ecs)
8362 if (ecs->event_thread->control.step_range_end != 0)
8367 if (ecs->event_thread->control.trap_expected
8368 && ecs->event_thread->stop_signal () != GDB_SIGNAL_TRAP)
8372 ecs->event_thread->ptid.to_string ().c_str ());
8373 keep_going (ecs);
8379 if (ecs->hit_singlestep_breakpoint)
8382 ecs->ptid.to_string ().c_str ());
8383 keep_going (ecs);
8390 if (thread_still_needs_step_over (ecs->event_thread))
8394 ecs->event_thread->ptid.to_string ().c_str ());
8395 keep_going (ecs);
8404 if (schedlock_applies (ecs->event_thread))
8410 ecs->event_thread->control.trap_expected = 0;
8413 if (!signal_program[ecs->event_thread->stop_signal ()])
8414 ecs->event_thread->set_stop_signal (GDB_SIGNAL_0);
8416 if (restart_stepped_thread (ecs->target, ecs->ptid))
8418 prepare_to_wait (ecs);
8422 switch_to_thread (ecs->event_thread);
8538 execution_control_state ecs (thr);
8540 keep_going (&ecs);
8583 execution_control_state ecs (tp);
8633 keep_going_pass_signal (&ecs);
8659 struct execution_control_state *ecs)
8661 fill_in_stop_func (gdbarch, ecs);
8664 = find_pc_compunit_symtab (ecs->event_thread->stop_pc ());
8666 ecs->stop_func_start
8667 = gdbarch_skip_prologue_noexcept (gdbarch, ecs->stop_func_start);
8669 symtab_and_line stop_func_sal = find_pc_line (ecs->stop_func_start, 0);
8677 && stop_func_sal.pc != ecs->stop_func_start
8678 && stop_func_sal.end < ecs->stop_func_end)
8679 ecs->stop_func_start = stop_func_sal.end;
8683 ``ecs->stop_func_start == stop_pc'' will never succeed. Adjust
8684 ecs->stop_func_start to an address at which a breakpoint may be
8699 ecs->stop_func_start
8701 ecs->stop_func_start);
8704 if (ecs->stop_func_start == ecs->event_thread->stop_pc ())
8707 end_stepping_range (ecs);
8714 sr_sal.pc = ecs->stop_func_start;
8715 sr_sal.section = find_pc_overlay (ecs->stop_func_start);
8724 ecs->event_thread->control.step_range_end
8725 = ecs->event_thread->control.step_range_start;
8727 keep_going (ecs);
8736 struct execution_control_state *ecs)
8741 fill_in_stop_func (gdbarch, ecs);
8743 cust = find_pc_compunit_symtab (ecs->event_thread->stop_pc ());
8745 ecs->stop_func_start
8746 = gdbarch_skip_prologue_noexcept (gdbarch, ecs->stop_func_start);
8748 stop_func_sal = find_pc_line (ecs->event_thread->stop_pc (), 0);
8751 if (stop_func_sal.pc == ecs->event_thread->stop_pc ())
8754 end_stepping_range (ecs);
8761 ecs->event_thread->control.step_range_start = stop_func_sal.pc;
8762 ecs->event_thread->control.step_range_end = stop_func_sal.end;
8763 keep_going (ecs);
8957 check_exception_resume (struct execution_control_state *ecs,
8970 insert_exception_resume_from_probe (ecs->event_thread, &probe, frame);
9007 insert_exception_resume_breakpoint (ecs->event_thread,
9019 stop_waiting (struct execution_control_state *ecs)
9024 ecs->wait_some_more = 0;
9031 keep_going_pass_signal (struct execution_control_state *ecs)
9033 gdb_assert (ecs->event_thread->ptid == inferior_ptid);
9034 gdb_assert (!ecs->event_thread->resumed ());
9037 ecs->event_thread->prev_pc
9038 = regcache_read_pc_protected (get_thread_regcache (ecs->event_thread));
9040 if (ecs->event_thread->control.trap_expected)
9042 struct thread_info *tp = ecs->event_thread;
9052 resume (ecs->event_thread->stop_signal ());
9059 struct thread_info *tp = ecs->event_thread;
9061 if (ecs->hit_singlestep_breakpoint
9075 regcache *regcache = get_thread_regcache (ecs->event_thread);
9099 step_what = thread_still_needs_step_over (ecs->event_thread);
9101 remove_bp = (ecs->hit_singlestep_breakpoint
9109 && (remove_wps || !use_displaced_stepping (ecs->event_thread)))
9111 set_step_over_info (ecs->event_thread->inf->aspace.get (),
9113 ecs->event_thread->global_num);
9134 stop_waiting (ecs);
9139 ecs->event_thread->control.trap_expected = (remove_bp || remove_wps);
9141 resume (ecs->event_thread->stop_signal ());
9144 prepare_to_wait (ecs);
9152 keep_going (struct execution_control_state *ecs)
9154 if (ecs->event_thread->control.trap_expected
9155 && ecs->event_thread->stop_signal () == GDB_SIGNAL_TRAP)
9156 ecs->event_thread->control.trap_expected = 0;
9158 if (!signal_program[ecs->event_thread->stop_signal ()])
9159 ecs->event_thread->set_stop_signal (GDB_SIGNAL_0);
9160 keep_going_pass_signal (ecs);
9168 prepare_to_wait (struct execution_control_state *ecs)
9172 ecs->wait_some_more = 1;
9186 end_stepping_range (struct execution_control_state *ecs)
9188 ecs->event_thread->control.stop_step = 1;
9189 stop_waiting (ecs);
Indexes created Mon Apr 20 00:23:12 UTC 2026