From patchwork Tue Feb 4 04:14:57 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Simon Marchi X-Patchwork-Id: 37669 Received: (qmail 69700 invoked by alias); 4 Feb 2020 04:15:05 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 69663 invoked by uid 89); 4 Feb 2020 04:15:03 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-19.0 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, RCVD_IN_DNSWL_LOW, SPF_SOFTFAIL autolearn=ham version=3.3.1 spammy=resume_1, gdb_signal, sig, SIG X-HELO: barracuda.ebox.ca Received: from barracuda.ebox.ca (HELO barracuda.ebox.ca) (96.127.255.19) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Tue, 04 Feb 2020 04:15:00 +0000 Received: from smtp.ebox.ca (smtp.ebox.ca [96.127.255.82]) by barracuda.ebox.ca with ESMTP id z3TGZfcg4ad4rvo9 (version=TLSv1 cipher=DHE-RSA-AES256-SHA bits=256 verify=NO); Mon, 03 Feb 2020 23:14:58 -0500 (EST) Received: from simark.lan (unknown [192.222.164.54]) by smtp.ebox.ca (Postfix) with ESMTP id EE73D441B21; Mon, 3 Feb 2020 23:14:57 -0500 (EST) From: Simon Marchi To: gdb-patches@sourceware.org Cc: Simon Marchi Subject: [pushed] Change ints to bools around thread_info executing/resumed Date: Mon, 3 Feb 2020 23:14:57 -0500 Message-Id: <20200204041457.905149-1-simon.marchi@polymtl.ca> MIME-Version: 1.0 X-IsSubscribed: yes From: Simon Marchi Switch thread_info::resumed to bool (thread_info::executing already is a bool), and try to change everything more or less related to that to consistently use true/false instead of 1/0. gdb/ChangeLog: * fork-child.c (gdb_startup_inferior): Use bool instead of int. * gdbthread.h (class thread_info) : Likewise. * infrun.c (resume_1): Likewise. (proceed): Likewise. (infrun_thread_stop_requested): Likewise. (stop_all_threads): Likewise. (handle_inferior_event): Likewise. (restart_threads): Likewise. (finish_step_over): Likewise. (keep_going_stepped_thread): Likewise. * linux-nat.c (attach_proc_task_lwp_callback): Likewise. (linux_handle_extended_wait): Likewise. * record-btrace.c (get_thread_current_frame_id): Likewise. * record-full.c (record_full_wait_1): Likewise. * remote.c (remote_target::process_initial_stop_replies): Likewise. * target.c (target_resume): Likewise. * thread.c (set_running_thread): Likewise. --- gdb/ChangeLog | 20 ++++++++++++++++++++ gdb/fork-child.c | 2 +- gdb/gdbthread.h | 6 +++--- gdb/infrun.c | 24 ++++++++++++------------ gdb/linux-nat.c | 8 ++++---- gdb/record-btrace.c | 2 +- gdb/record-full.c | 4 ++-- gdb/remote.c | 4 ++-- gdb/target.c | 2 +- gdb/thread.c | 8 ++++---- 10 files changed, 50 insertions(+), 30 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index f9ef0e150894..504961bdc900 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,23 @@ +2020-02-03 Simon Marchi + + * fork-child.c (gdb_startup_inferior): Use bool instead of int. + * gdbthread.h (class thread_info) : Likewise. + * infrun.c (resume_1): Likewise. + (proceed): Likewise. + (infrun_thread_stop_requested): Likewise. + (stop_all_threads): Likewise. + (handle_inferior_event): Likewise. + (restart_threads): Likewise. + (finish_step_over): Likewise. + (keep_going_stepped_thread): Likewise. + * linux-nat.c (attach_proc_task_lwp_callback): Likewise. + (linux_handle_extended_wait): Likewise. + * record-btrace.c (get_thread_current_frame_id): Likewise. + * record-full.c (record_full_wait_1): Likewise. + * remote.c (remote_target::process_initial_stop_replies): Likewise. + * target.c (target_resume): Likewise. + * thread.c (set_running_thread): Likewise. + 2020-02-03 Alok Kumar Sharma * f-valprint.c (f77_print_array_1): Changed datatype of index diff --git a/gdb/fork-child.c b/gdb/fork-child.c index 010414cc781b..41d5e2a0a47b 100644 --- a/gdb/fork-child.c +++ b/gdb/fork-child.c @@ -134,7 +134,7 @@ gdb_startup_inferior (pid_t pid, int num_traps) ptid_t ptid = startup_inferior (proc_target, pid, num_traps, NULL, NULL); /* Mark all threads non-executing. */ - set_executing (proc_target, ptid, 0); + set_executing (proc_target, ptid, false); return ptid; } diff --git a/gdb/gdbthread.h b/gdb/gdbthread.h index f205e29dd7dd..717a2ad08c2f 100644 --- a/gdb/gdbthread.h +++ b/gdb/gdbthread.h @@ -301,20 +301,20 @@ public: if the thread does not have a user-given name. */ char *name = NULL; - /* Non-zero means the thread is executing. Note: this is different + /* True means the thread is executing. Note: this is different from saying that there is an active target and we are stopped at a breakpoint, for instance. This is a real indicator whether the thread is off and running. */ bool executing = false; - /* Non-zero if this thread is resumed from infrun's perspective. + /* True if this thread is resumed from infrun's perspective. Note that a thread can be marked both as not-executing and resumed at the same time. This happens if we try to resume a thread that has a wait status pending. We shouldn't let the thread really run until that wait status has been processed, but we should not process that wait status if we didn't try to let the thread run. */ - int resumed = 0; + bool resumed = false; /* Frontend view of the thread state. Note that the THREAD_RUNNING/ THREAD_STOPPED states are different from EXECUTING. When the diff --git a/gdb/infrun.c b/gdb/infrun.c index c8369cbee2e8..3e846f8e6802 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -2282,7 +2282,7 @@ resume_1 (enum gdb_signal sig) } tp->inf->process_target ()->threads_executing = true; - tp->resumed = 1; + tp->resumed = true; /* FIXME: What should we do if we are supposed to resume this thread with a signal? Maybe we should maintain a queue of @@ -2410,7 +2410,7 @@ resume_1 (enum gdb_signal sig) resume_ptid = internal_resume_ptid (user_step); do_target_resume (resume_ptid, 0, GDB_SIGNAL_0); - tp->resumed = 1; + tp->resumed = true; return; } } @@ -2622,7 +2622,7 @@ resume_1 (enum gdb_signal sig) } do_target_resume (resume_ptid, step, sig); - tp->resumed = 1; + tp->resumed = true; } /* Resume the inferior. SIG is the signal to give the inferior @@ -3022,7 +3022,7 @@ proceed (CORE_ADDR addr, enum gdb_signal siggnal) inferior function, as in that case we pretend the inferior doesn't run at all. */ if (!cur_thr->control.in_infcall) - set_running (resume_target, resume_ptid, 1); + set_running (resume_target, resume_ptid, true); if (debug_infrun) fprintf_unfiltered (gdb_stdlog, @@ -3306,7 +3306,7 @@ infrun_thread_stop_requested (ptid_t ptid) /* Otherwise we can process the (new) pending event now. Set it so this pending event is considered by do_target_wait. */ - tp->resumed = 1; + tp->resumed = true; } } @@ -4749,7 +4749,7 @@ stop_all_threads (void) /* The thread may be not executing, but still be resumed with a pending status to process. */ - t->resumed = 0; + t->resumed = false; } } @@ -4788,7 +4788,7 @@ stop_all_threads (void) t->stop_requested = 0; t->executing = 0; - t->resumed = 0; + t->resumed = false; t->control.may_range_step = 0; /* This may be the first time we see the inferior report @@ -5126,10 +5126,10 @@ handle_inferior_event (struct execution_control_state *ecs) else mark_ptid = ecs->ptid; - set_executing (ecs->target, mark_ptid, 0); + set_executing (ecs->target, mark_ptid, false); /* Likewise the resumed flag. */ - set_resumed (ecs->target, mark_ptid, 0); + set_resumed (ecs->target, mark_ptid, false); } switch (ecs->ws.kind) @@ -5623,7 +5623,7 @@ restart_threads (struct thread_info *event_thread) "infrun: restart threads: " "[%s] has pending status\n", target_pid_to_str (tp->ptid).c_str ()); - tp->resumed = 1; + tp->resumed = true; continue; } @@ -5763,7 +5763,7 @@ finish_step_over (struct execution_control_state *ecs) /* This was cleared early, by handle_inferior_event. Set it so this pending event is considered by do_target_wait. */ - tp->resumed = 1; + tp->resumed = true; gdb_assert (!tp->executing); @@ -7424,7 +7424,7 @@ keep_going_stepped_thread (struct thread_info *tp) get_frame_address_space (frame), tp->suspend.stop_pc); - tp->resumed = 1; + tp->resumed = true; resume_ptid = internal_resume_ptid (tp->control.stepping_command); do_target_resume (resume_ptid, 0, GDB_SIGNAL_0); } diff --git a/gdb/linux-nat.c b/gdb/linux-nat.c index e7533a993093..230ae366b641 100644 --- a/gdb/linux-nat.c +++ b/gdb/linux-nat.c @@ -1166,8 +1166,8 @@ attach_proc_task_lwp_callback (ptid_t ptid) matching libthread_db is not found (or the process uses raw clone). */ add_thread (linux_target, lp->ptid); - set_running (linux_target, lp->ptid, 1); - set_executing (linux_target, lp->ptid, 1); + set_running (linux_target, lp->ptid, true); + set_executing (linux_target, lp->ptid, true); } return 1; @@ -2038,8 +2038,8 @@ linux_handle_extended_wait (struct lwp_info *lp, int status) internal to this module, from the perspective of infrun and the user/frontend, this new thread is running until it next reports a stop. */ - set_running (linux_target, new_lp->ptid, 1); - set_executing (linux_target, new_lp->ptid, 1); + set_running (linux_target, new_lp->ptid, true); + set_executing (linux_target, new_lp->ptid, true); if (WSTOPSIG (status) != SIGSTOP) { diff --git a/gdb/record-btrace.c b/gdb/record-btrace.c index 619ecde025b9..ef23a0b7af76 100644 --- a/gdb/record-btrace.c +++ b/gdb/record-btrace.c @@ -1958,7 +1958,7 @@ static struct frame_id get_thread_current_frame_id (struct thread_info *tp) { struct frame_id id; - int executing; + bool executing; /* Set current thread, which is implicitly used by get_current_frame. */ diff --git a/gdb/record-full.c b/gdb/record-full.c index 16966220e0f0..51b7beabf668 100644 --- a/gdb/record-full.c +++ b/gdb/record-full.c @@ -1267,12 +1267,12 @@ record_full_wait_1 (struct target_ops *ops, /* Try to insert the software single step breakpoint. If insert success, set step to 0. */ - set_executing (proc_target, inferior_ptid, 0); + set_executing (proc_target, inferior_ptid, false); reinit_frame_cache (); step = !insert_single_step_breakpoints (gdbarch); - set_executing (proc_target, inferior_ptid, 1); + set_executing (proc_target, inferior_ptid, true); } if (record_debug) diff --git a/gdb/remote.c b/gdb/remote.c index be2987707ff7..dafdfa8f6c92 100644 --- a/gdb/remote.c +++ b/gdb/remote.c @@ -4449,8 +4449,8 @@ remote_target::process_initial_stop_replies (int from_tty) || ws.value.sig != GDB_SIGNAL_0) evthread->suspend.waitstatus_pending_p = 1; - set_executing (this, event_ptid, 0); - set_running (this, event_ptid, 0); + set_executing (this, event_ptid, false); + set_running (this, event_ptid, false); get_remote_thread_info (evthread)->vcont_resumed = 0; } diff --git a/gdb/target.c b/gdb/target.c index b24d3d899e80..470ef51d69ef 100644 --- a/gdb/target.c +++ b/gdb/target.c @@ -2127,7 +2127,7 @@ target_resume (ptid_t ptid, int step, enum gdb_signal signal) /* We only set the internal executing state here. The user/frontend running state is set at a higher level. This also clears the thread's stop_pc as side effect. */ - set_executing (curr_target, ptid, 1); + set_executing (curr_target, ptid, true); clear_inline_frame_state (curr_target, ptid); } diff --git a/gdb/thread.c b/gdb/thread.c index 302a49e9845e..54b59e22448a 100644 --- a/gdb/thread.c +++ b/gdb/thread.c @@ -823,13 +823,13 @@ set_resumed (process_stratum_target *targ, ptid_t ptid, bool resumed) /* Helper for set_running, that marks one thread either running or stopped. */ -static int -set_running_thread (struct thread_info *tp, int running) +static bool +set_running_thread (struct thread_info *tp, bool running) { - int started = 0; + bool started = false; if (running && tp->state == THREAD_STOPPED) - started = 1; + started = true; tp->state = running ? THREAD_RUNNING : THREAD_STOPPED; if (!running)