From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 17101 invoked by alias); 7 Dec 2008 00:18:23 -0000 Received: (qmail 17091 invoked by uid 22791); 7 Dec 2008 00:18:22 -0000 X-Spam-Check-By: sourceware.org Received: from mtagate6.de.ibm.com (HELO mtagate6.de.ibm.com) (195.212.29.155) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Sun, 07 Dec 2008 00:17:39 +0000 Received: from d12nrmr1607.megacenter.de.ibm.com (d12nrmr1607.megacenter.de.ibm.com [9.149.167.49]) by mtagate6.de.ibm.com (8.13.8/8.13.8) with ESMTP id mB70Haju150982 for ; Sun, 7 Dec 2008 00:17:36 GMT Received: from d12av02.megacenter.de.ibm.com (d12av02.megacenter.de.ibm.com [9.149.165.228]) by d12nrmr1607.megacenter.de.ibm.com (8.13.8/8.13.8/NCO v9.1) with ESMTP id mB70Ha6U3977434 for ; Sun, 7 Dec 2008 01:17:36 +0100 Received: from d12av02.megacenter.de.ibm.com (loopback [127.0.0.1]) by d12av02.megacenter.de.ibm.com (8.12.11.20060308/8.13.3) with ESMTP id mB70Ha6q018381 for ; Sun, 7 Dec 2008 01:17:36 +0100 Received: from tuxmaker.boeblingen.de.ibm.com (tuxmaker.boeblingen.de.ibm.com [9.152.85.9]) by d12av02.megacenter.de.ibm.com (8.12.11.20060308/8.12.11) with SMTP id mB70HagV018378 for ; Sun, 7 Dec 2008 01:17:36 +0100 Message-Id: <200812070017.mB70HagV018378@d12av02.megacenter.de.ibm.com> Received: by tuxmaker.boeblingen.de.ibm.com (sSMTP sendmail emulation); Sun, 7 Dec 2008 01:17:36 +0100 Subject: [rfc] [2/7] infrun cleanup: miscellaneous cleanups To: gdb-patches@sourceware.org Date: Sun, 07 Dec 2008 00:18:00 -0000 From: "Ulrich Weigand" MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Transfer-Encoding: 7bit Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2008-12/txt/msg00120.txt.bz2 Hello, this patch performs a number of cleanups that the follwoing patches depend upon. While I think that this patch should have no effect on GDB behaviour, this is less obviously the case that for the follow-on patches (which are clearly mechanical changes). Therefore, I'd definitely appreciate feedback in particular on this patch. The changes are in detail: * handle_inferior_event is made static. * prepare_to_wait performs some cleanup in preparation for another target_wait call, most notably calling registers_changed. It does this only in infwait_normal_state -- but in those places where another infwait_state is chosen, handle_inferior_event actually calls registers_changed itself. This patch changes wait_for_inferior to *always* invalidate registers (and overlay cache state) before every call to target_wait, and removes this from prepare_to_wait and handle_inferior_event. * prepare_to_wait also resets waiton_ptid. This is moved into handle_inferior_event at the place where infwait_state is reset (those two globals really should always be set at the same time). * fetch_inferior_event uses the contents of ecs->ptid and ecs->event_thread after handle_inferior_event returns. As later patches will remove those fields, I've replaced them with accessing the current inferior -- just like normal_stop, which is called by fetch_inferior_event anyway, does as well. * Finally, some dead code is removed: infrun_thread_stop_requested_callback sets ecs->event_thread before calling handle_inferior_event -- which is always ignored and re-computed by that routine. fetch_inferior_event performs a check for !ecs->wait_some_more -- immediately after memsetting the ecs structure to zero. And finally handle_step_into_function_backward computes the function end-of-prologue address -- without ever using it. Bye, Ulrich ChangeLog: * infrun.c (infrun_thread_stop_requested_callback): Do not set ecs->event_thread before calling handle_inferior_event. (fetch_inferior_event): Remove check for always-true condition. Do not rely on contents of ecs->ptid or ecs->event_thread after calling handle_inferior_event. (handle_step_into_function_backward): Do not modify (unused) ecs->stop_func_start. (wait_for_inferior): Invalidate registers and overlay cache every time before calling target_wait. (handle_inferior_event): Make static. Always reset waiton_ptid. Never call registers_changed. (prepare_to_wait): Do not invaliate registers or overlay cache (moved to wait_for_inferior). Do not reset waiton_ptid (moved to handle_inferior_event). Index: gdb-head/gdb/infrun.c =================================================================== --- gdb-head.orig/gdb/infrun.c +++ gdb-head/gdb/infrun.c @@ -1581,7 +1581,7 @@ struct execution_control_state void init_execution_control_state (struct execution_control_state *ecs); -void handle_inferior_event (struct execution_control_state *ecs); +static void handle_inferior_event (struct execution_control_state *ecs); static void handle_step_into_function (struct execution_control_state *ecs); static void handle_step_into_function_backward (struct execution_control_state *ecs); @@ -1631,7 +1631,6 @@ infrun_thread_stop_requested_callback (s have consistent output as if the stop event had been reported. */ ecs->ptid = info->ptid; - ecs->event_thread = find_thread_pid (info->ptid); ecs->ws.kind = TARGET_WAITKIND_STOPPED; ecs->ws.value.sig = TARGET_SIGNAL_0; @@ -1761,21 +1760,20 @@ wait_for_inferior (void) ecs = &ecss; memset (ecs, 0, sizeof (*ecs)); - overlay_cache_invalid = 1; - /* We'll update this if & when we switch to a new thread. */ previous_inferior_ptid = inferior_ptid; - /* We have to invalidate the registers BEFORE calling target_wait - because they can be loaded from the target while in target_wait. - This makes remote debugging a bit more efficient for those - targets that provide critical registers as part of their normal - status mechanism. */ - - registers_changed (); - while (1) { + /* We have to invalidate the registers BEFORE calling target_wait + because they can be loaded from the target while in target_wait. + This makes remote debugging a bit more efficient for those + targets that provide critical registers as part of their normal + status mechanism. */ + + overlay_cache_invalid = 1; + registers_changed (); + if (deprecated_target_wait_hook) ecs->ptid = deprecated_target_wait_hook (waiton_ptid, &ecs->ws); else @@ -1810,14 +1808,8 @@ fetch_inferior_event (void *client_data) memset (ecs, 0, sizeof (*ecs)); - overlay_cache_invalid = 1; - - /* We can only rely on wait_for_more being correct before handling - the event in all-stop, but previous_inferior_ptid isn't used in - non-stop. */ - if (!ecs->wait_some_more) - /* We'll update this if & when we switch to a new thread. */ - previous_inferior_ptid = inferior_ptid; + /* We'll update this if & when we switch to a new thread. */ + previous_inferior_ptid = inferior_ptid; if (non_stop) /* In non-stop mode, the user/frontend should not notice a thread @@ -1832,6 +1824,7 @@ fetch_inferior_event (void *client_data) targets that provide critical registers as part of their normal status mechanism. */ + overlay_cache_invalid = 1; registers_changed (); if (deprecated_target_wait_hook) @@ -1854,7 +1847,7 @@ fetch_inferior_event (void *client_data) if (!ecs->wait_some_more) { - struct inferior *inf = find_inferior_pid (ptid_get_pid (ecs->ptid)); + struct inferior *inf = current_inferior (); delete_step_thread_step_resume_breakpoint (); @@ -1865,8 +1858,8 @@ fetch_inferior_event (void *client_data) if (target_has_execution && ecs->ws.kind != TARGET_WAITKIND_EXITED && ecs->ws.kind != TARGET_WAITKIND_SIGNALLED - && ecs->event_thread->step_multi - && ecs->event_thread->stop_step) + && inferior_thread ()->step_multi + && inferior_thread ()->stop_step) inferior_event_handler (INF_EXEC_CONTINUE, NULL); else inferior_event_handler (INF_EXEC_COMPLETE, NULL); @@ -2078,7 +2071,7 @@ ensure_not_running (void) by an event from the inferior, figure out what it means and take appropriate action. */ -void +static void handle_inferior_event (struct execution_control_state *ecs) { int sw_single_step_trap_p = 0; @@ -2141,8 +2134,6 @@ handle_inferior_event (struct execution_ case infwait_thread_hop_state: if (debug_infrun) fprintf_unfiltered (gdb_stdlog, "infrun: infwait_thread_hop_state\n"); - /* Cancel the waiton_ptid. */ - waiton_ptid = pid_to_ptid (-1); break; case infwait_normal_state: @@ -2173,7 +2164,9 @@ handle_inferior_event (struct execution_ default: internal_error (__FILE__, __LINE__, _("bad switch")); } + infwait_state = infwait_normal_state; + waiton_ptid = pid_to_ptid (-1); switch (ecs->ws.kind) { @@ -2665,7 +2658,6 @@ targets should add new threads to the th ecs->event_thread->stepping_over_breakpoint = 1; keep_going (ecs); - registers_changed (); return; } } @@ -2732,7 +2724,6 @@ targets should add new threads to the th if (!HAVE_STEPPABLE_WATCHPOINT) remove_breakpoints (); - registers_changed (); target_resume (ecs->ptid, 1, TARGET_SIGNAL_0); /* Single step */ waiton_ptid = ecs->ptid; if (HAVE_STEPPABLE_WATCHPOINT) @@ -3765,14 +3756,7 @@ handle_step_into_function (struct execut static void handle_step_into_function_backward (struct execution_control_state *ecs) { - struct symtab *s; - struct symtab_and_line stop_func_sal, sr_sal; - - s = find_pc_symtab (stop_pc); - if (s && s->language != language_asm) - ecs->stop_func_start = gdbarch_skip_prologue (current_gdbarch, - ecs->stop_func_start); - + struct symtab_and_line stop_func_sal; stop_func_sal = find_pc_line (stop_pc, 0); /* OK, we're just going to keep stepping here. */ @@ -3998,19 +3982,7 @@ prepare_to_wait (struct execution_contro { if (debug_infrun) fprintf_unfiltered (gdb_stdlog, "infrun: prepare_to_wait\n"); - if (infwait_state == infwait_normal_state) - { - overlay_cache_invalid = 1; - - /* We have to invalidate the registers BEFORE calling - target_wait because they can be loaded from the target while - in target_wait. This makes remote debugging a bit more - efficient for those targets that provide critical registers - as part of their normal status mechanism. */ - registers_changed (); - waiton_ptid = pid_to_ptid (-1); - } /* This is the old end of the while loop. Let everybody know we want to wait for the inferior some more and get called again soon. */ -- Dr. Ulrich Weigand GNU Toolchain for Linux on System z and Cell BE Ulrich.Weigand@de.ibm.com