From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 10787 invoked by alias); 15 Mar 2009 19:44:37 -0000 Received: (qmail 10775 invoked by uid 22791); 15 Mar 2009 19:44:36 -0000 X-SWARE-Spam-Status: No, hits=-2.4 required=5.0 tests=AWL,BAYES_00 X-Spam-Check-By: sourceware.org Received: from rock.gnat.com (HELO rock.gnat.com) (205.232.38.15) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Sun, 15 Mar 2009 19:44:31 +0000 Received: from localhost (localhost.localdomain [127.0.0.1]) by filtered-rock.gnat.com (Postfix) with ESMTP id 898EB2BAB33 for ; Sun, 15 Mar 2009 15:44:29 -0400 (EDT) Received: from rock.gnat.com ([127.0.0.1]) by localhost (rock.gnat.com [127.0.0.1]) (amavisd-new, port 10024) with LMTP id 9O8ONke2vhsn for ; Sun, 15 Mar 2009 15:44:29 -0400 (EDT) Received: from joel.gnat.com (localhost.localdomain [127.0.0.1]) by rock.gnat.com (Postfix) with ESMTP id 605022BAB30 for ; Sun, 15 Mar 2009 15:44:29 -0400 (EDT) Received: by joel.gnat.com (Postfix, from userid 1000) id 5F8A4F5C3F; Sun, 15 Mar 2009 12:44:28 -0700 (PDT) Date: Sun, 15 Mar 2009 19:46:00 -0000 From: Joel Brobecker To: gdb-patches@sourceware.org Subject: [commit/AIX] Debugger is crashing when debugging program Message-ID: <20090315194428.GA9576@adacore.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="bg08WKrSYDhXBjb5" Content-Disposition: inline User-Agent: Mutt/1.5.18 (2008-05-17) 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: 2009-03/txt/msg00240.txt.bz2 --bg08WKrSYDhXBjb5 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline Content-length: 1724 Hello, On AIX, we were no longer able to debug a simple program: (gdb) start Temporary breakpoint 1 at 0x10041548: file task_switch.adb, line 7. Starting program: /[...]/task_switch zsh: 675900 illegal hardware instruction (core dumped) /[...]/gdb task_switch This is because we were using an global target_ops to store the target underneath the AIX thread layer, and this global wasn't really as well initiatialized as you'd think. That was a good opportunity for getting rid of it. As I was working on this, I wondered why the aix_thread_kill was needed at all. The only think that this method does extra is preserving the inferior ptid. I don't see why this is necessary. I did a little bit of testing and found nothing wrong with removing it, so I removed it, at least for now. 2009-03-15 Joel Brobecker Modernize the aix-thread later by getting rid of the base_target global. This brings back to life the AIX port which was otherwise crashing all the time. * aix-thread.c (base_target): Delete. (pd_enable): Do not set base_target. (aix_thread_attach): Use find_target_beneath instead of base_target. (aix_thread_detach, aix_thread_resume, aix_thread_wait) (aix_thread_fetch_registers, aix_thread_store_registers), (aix_thread_xfer_partial, aix_thread_mourn_inferior) (aix_thread_thread_alive, aix_thread_pid_to_str): Likewise. (aix_thread_kill): Delete. Does not seem necessary. (init_aix_thread_ops): Do not set aix_thread_ops.to_kill. Tested on powerpc-aix. Checked in. The only regression left that I'm seeing, now, is with core files. Looking into it... -- Joel --bg08WKrSYDhXBjb5 Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="aix-thread.diff" Content-length: 5743 Index: aix-thread.c =================================================================== --- aix-thread.c (revision 146288) +++ aix-thread.c (revision 146289) @@ -105,12 +105,6 @@ struct pd_thread { static struct target_ops aix_thread_ops; -/* Copy of the target over which ops is pushed. This is more - convenient than a pointer to deprecated_child_ops or core_ops, - because they lack current_target's default callbacks. */ - -static struct target_ops base_target; - /* Address of the function that libpthread will call when libpthdebug is ready to be initialized. */ @@ -897,7 +891,6 @@ pd_enable (void) return; /* Prepare for thread debugging. */ - base_target = current_target; push_target (&aix_thread_ops); pd_able = 1; @@ -941,7 +934,9 @@ new_objfile (struct objfile *objfile) static void aix_thread_attach (struct target_ops *ops, char *args, int from_tty) { - base_target.to_attach (&base_target, args, from_tty); + struct target_ops *beneath = find_target_beneath (ops); + + beneath->to_attach (beneath, args, from_tty); pd_activate (1); } @@ -950,8 +945,10 @@ aix_thread_attach (struct target_ops *op static void aix_thread_detach (struct target_ops *ops, char *args, int from_tty) { + struct target_ops *beneath = find_target_beneath (ops); + pd_disable (); - base_target.to_detach (&base_target, args, from_tty); + beneath->to_detach (beneath, args, from_tty); } /* Tell the inferior process to continue running thread PID if != -1 @@ -967,8 +964,10 @@ aix_thread_resume (struct target_ops *op if (!PD_TID (ptid)) { struct cleanup *cleanup = save_inferior_ptid (); + struct target_ops *beneath = find_target_beneath (ops); + inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid)); - base_target.to_resume (ops, ptid, step, sig); + beneath->to_resume (beneath, ptid, step, sig); do_cleanups (cleanup); } else @@ -1002,11 +1001,12 @@ aix_thread_wait (struct target_ops *ops, ptid_t ptid, struct target_waitstatus *status) { struct cleanup *cleanup = save_inferior_ptid (); + struct target_ops *beneath = find_target_beneath (ops); pid_to_prc (&ptid); inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid)); - ptid = base_target.to_wait (&base_target, ptid, status); + ptid = beneath->to_wait (beneath, ptid, status); do_cleanups (cleanup); if (PIDGET (ptid) == -1) @@ -1282,9 +1282,10 @@ aix_thread_fetch_registers (struct targe { struct thread_info *thread; pthdb_tid_t tid; + struct target_ops *beneath = find_target_beneath (ops); if (!PD_TID (inferior_ptid)) - base_target.to_fetch_registers (ops, regcache, regno); + beneath->to_fetch_registers (beneath, regcache, regno); else { thread = find_thread_pid (inferior_ptid); @@ -1622,9 +1623,10 @@ aix_thread_store_registers (struct targe { struct thread_info *thread; pthdb_tid_t tid; + struct target_ops *beneath = find_target_beneath (ops); if (!PD_TID (inferior_ptid)) - base_target.to_store_registers (ops, regcache, regno); + beneath->to_store_registers (beneath, regcache, regno); else { thread = find_thread_pid (inferior_ptid); @@ -1648,34 +1650,25 @@ aix_thread_xfer_partial (struct target_o { struct cleanup *old_chain = save_inferior_ptid (); LONGEST xfer; + struct target_ops *beneath = find_target_beneath (ops); inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid)); - xfer = base_target.to_xfer_partial (ops, object, annex, - readbuf, writebuf, offset, len); + xfer = beneath->to_xfer_partial (beneath, object, annex, + readbuf, writebuf, offset, len); do_cleanups (old_chain); return xfer; } -/* Kill and forget about the inferior process. */ - -static void -aix_thread_kill (void) -{ - struct cleanup *cleanup = save_inferior_ptid (); - - inferior_ptid = pid_to_ptid (PIDGET (inferior_ptid)); - base_target.to_kill (); - do_cleanups (cleanup); -} - /* Clean up after the inferior exits. */ static void aix_thread_mourn_inferior (struct target_ops *ops) { + struct target_ops *beneath = find_target_beneath (ops); + pd_deactivate (); - base_target.to_mourn_inferior (&base_target); + beneath->to_mourn_inferior (beneath); } /* Return whether thread PID is still valid. */ @@ -1683,8 +1676,10 @@ aix_thread_mourn_inferior (struct target static int aix_thread_thread_alive (struct target_ops *ops, ptid_t ptid) { + struct target_ops *beneath = find_target_beneath (¤t_target); + if (!PD_TID (ptid)) - return base_target.to_thread_alive (ops, ptid); + return beneath->to_thread_alive (beneath, ptid); /* We update the thread list every time the child stops, so all valid threads should be in the thread list. */ @@ -1698,9 +1693,10 @@ static char * aix_thread_pid_to_str (struct target_ops *ops, ptid_t ptid) { static char *ret = NULL; + struct target_ops *beneath = find_target_beneath (¤t_target); if (!PD_TID (ptid)) - return base_target.to_pid_to_str (&base_target, ptid); + return beneath->to_pid_to_str (beneath, ptid); /* Free previous return value; a new one will be allocated by xstrprintf(). */ @@ -1795,7 +1791,6 @@ init_aix_thread_ops (void) aix_thread_ops.to_xfer_partial = aix_thread_xfer_partial; /* No need for aix_thread_ops.to_create_inferior, because we activate thread debugging when the inferior reaches pd_brk_addr. */ - aix_thread_ops.to_kill = aix_thread_kill; aix_thread_ops.to_mourn_inferior = aix_thread_mourn_inferior; aix_thread_ops.to_thread_alive = aix_thread_thread_alive; aix_thread_ops.to_pid_to_str = aix_thread_pid_to_str; --bg08WKrSYDhXBjb5--