From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 15798 invoked by alias); 6 Sep 2002 20:55:02 -0000 Mailing-List: contact gdb-patches-help@sources.redhat.com; run by ezmlm Precedence: bulk List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sources.redhat.com Received: (qmail 15788 invoked from network); 6 Sep 2002 20:55:01 -0000 Received: from unknown (HELO cygnus.com) (205.180.83.203) by sources.redhat.com with SMTP; 6 Sep 2002 20:55:01 -0000 Received: from porcupine.slc.redhat.com (vpn50-9.rdu.redhat.com [172.16.50.9]) by runyon.cygnus.com (8.8.7-cygnus/8.8.7) with ESMTP id NAA16795 for ; Fri, 6 Sep 2002 13:45:21 -0700 (PDT) Received: from porcupine (law@localhost) by porcupine.slc.redhat.com (8.11.6/8.11.6) with ESMTP id g86Kxgc10659 for ; Fri, 6 Sep 2002 14:59:43 -0600 Message-Id: <200209062059.g86Kxgc10659@porcupine.slc.redhat.com> To: gdb-patches@sources.redhat.com Reply-To: law@redhat.com Subject: fix interrupt.exp for hpux11 Mime-Version: 1.0 Content-Type: text/plain; charset=us-ascii Date: Fri, 06 Sep 2002 13:55:00 -0000 From: Jeff Law X-SW-Source: 2002-09/txt/msg00098.txt.bz2 This is a repost of a patch I submitted last year, but which was never approved. It's incorrect to use TT_PROC_CONTINUE in this context due to its inability to pass along (or clear pending) signals. This fixes interrupt.exp for hpux11. * infttrace.c (child_resume): Simplify and rework to avoid TT_PROC_CONTINUE. Index: infttrace.c =================================================================== RCS file: /cvs/src/src/gdb/infttrace.c,v retrieving revision 1.19 diff -c -3 -p -r1.19 infttrace.c *** infttrace.c 21 Jan 2002 01:27:01 -0000 1.19 --- infttrace.c 6 Sep 2002 20:51:47 -0000 *************** child_resume (ptid_t ptid, int step, enu *** 4539,4636 **** else { ! /* TT_LWP_CONTINUE can pass signals to threads, ! * TT_PROC_CONTINUE can't. So if there are any ! * signals to pass, we have to use the (slower) ! * loop over the stopped threads. ! * ! * Equally, if we have to not continue some threads, ! * due to saved events, we have to use the loop. ! */ ! if ((signal != 0) || saved_signals_exist ()) ! { ! if (resume_all_threads) ! { ! ! #ifdef THREAD_DEBUG ! if (debug_on) ! printf ("Doing a continue by loop of all threads\n"); ! #endif ! threads_continue_all_with_signals (tid, signal); ! ! clear_all_handled (); ! clear_all_stepping_mode (); ! } ! ! else ! { #ifdef THREAD_DEBUG ! printf ("Doing a continue w/signal of just thread %d\n", tid); #endif ! threads_continue_one_with_signal (tid, signal); ! /* Clear the "handled" state of this thread, because ! * we'll soon get a new event for it. Other events ! * can stay as they were. ! */ ! clear_handled (tid); ! clear_stepping_mode (tid); ! } } - else { - /* No signals to send. - */ - if (resume_all_threads) - { - #ifdef THREAD_DEBUG - if (debug_on) - printf ("Doing a continue by process of process %d\n", tid); - #endif - - if (more_events_left > 0) - { - warning ("Losing buffered events on continue."); - more_events_left = 0; - } - - call_ttrace (TT_PROC_CONTINUE, - tid, - TT_NIL, - TT_NIL, - TT_NIL); - - clear_all_handled (); - clear_all_stepping_mode (); - } - - else - { #ifdef THREAD_DEBUG ! if (debug_on) ! { ! printf ("Doing a continue of just thread %d\n", tid); ! if (is_terminated (tid)) ! printf ("Why are we continuing a dead thread? (5)\n"); ! } #endif ! call_ttrace (TT_LWP_CONTINUE, ! tid, ! TT_NIL, ! TT_NIL, ! TT_NIL); ! /* Clear the "handled" state of this thread, because ! * we'll soon get a new event for it. Other events ! * can stay as they were. ! */ ! clear_handled (tid); ! clear_stepping_mode (tid); ! } } } --- 4539,4579 ---- else { ! /* TT_LWP_CONTINUE can pass signals to threads, TT_PROC_CONTINUE can't. ! Therefore, we really can't use TT_PROC_CONTINUE here. ! Consider a process which stopped due to signal which gdb decides ! to handle and not pass on to the inferior. In that case we must ! clear the pending signal by restarting the inferior using ! TT_LWP_CONTINUE and pass zero as the signal number. Else the ! pending signal will be passed to the inferior. interrupt.exp ! in the testsuite does this precise thing and fails due to the ! unwanted signal delivery to the inferior. */ ! if (resume_all_threads) ! { #ifdef THREAD_DEBUG ! if (debug_on) ! printf ("Doing a continue by loop of all threads\n"); #endif ! threads_continue_all_with_signals (tid, signal); ! clear_all_handled (); ! clear_all_stepping_mode (); } else { #ifdef THREAD_DEBUG ! printf ("Doing a continue w/signal of just thread %d\n", tid); #endif ! threads_continue_one_with_signal (tid, signal); ! /* Clear the "handled" state of this thread, because we ! will soon get a new event for it. Other events can ! stay as they were. */ ! clear_handled (tid); ! clear_stepping_mode (tid); } }