Re: [PATCH] Use current_inferior ()->pid for AIX

[Simon Marchi <simon.marchi@polymtl.ca>]

> diff --git a/gdb/rs6000-aix-nat.c b/gdb/rs6000-aix-nat.c
> index 5cf1214c65e..d4d181b155e 100644
> --- a/gdb/rs6000-aix-nat.c
> +++ b/gdb/rs6000-aix-nat.c
> @@ -529,7 +529,7 @@ rs6000_nat_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
>  	}
>
>        /* Ignore terminated detached child processes.  */
> -      if (!WIFSTOPPED (status) && pid != inferior_ptid.pid ())
> +      if (!WIFSTOPPED (status) && pid != pid_t(current_inferior ()->pid))

As stated in my previous message, you should not assume which is the
current inferior, when entering the wait method.  The current code was
written a while ago, probably before GDB gained support for
multi-inferior.  So if we are to change this code, we should bring it up
to current standards, as much as possible.

Imagine that your target is currently debugging two inferiors executing
simultaneously (I don't know if the AIX target supports that, but let's
pretend that it does).  The event you get from waitpid could be for
either inferior.  So you can't simply ignore an event if it is for the
non-current inferior.

When you have a multi-threaded (pthread) inferior on AIX and call
waitpid on it, what does it return when some thread get a signal?  Does
it return the pid of the process, or a specific tid?  My reading of the
code in aix-thread.c and of the snippet above makes me think that the
kernel returns the process' pid.  And then get_signaled_thread in
aix-thread.c takes care of finding the specific thread that got a
signal, somehow.

So my intuition is that here it would make sense to call
find_inferior_pid with the value returned by waitpid, to see if this is
for an inferior we know or for a "terminated detached child process", as
the comment above says.  If we have no inferior with that pid, we can
probably ignore the event.  If we have an inferior with that pid, then
we return its pid and status.

Note that inferior_ptid variable at this point will still be null_ptid
(and that's ok).  Back in aix_thread_target::wait (if using the
aix-thread target), the simplest thing to do is probably to call
find_inferior_pid with the pid returned by `beneath ()->wait` and make
it the current inferior with switch_to_inferior_no_thread.  Then, the
rest of the code (pd_update and pd_activate) can correctly assume that
they have the right current inferior, so can use
`current_inferior()->pid`.

I don't know if that actually makes sense.  I would actually try it on
an AIX machine on the GCC compile farm, but I can't get GDB to build on
it, and I don't really have time to look into it:

  CXX      thread-pool.o
In file included from ../../src/binutils-gdb/gdbsupport/thread-pool.cc:21:0:
../../src/binutils-gdb/gdbsupport/../gdbsupport/thread-pool.h: In member function 'std::future<void> gdb::thread_pool::post_task(std::function<void()>&&)':
../../src/binutils-gdb/gdbsupport/../gdbsupport/thread-pool.h:68:3: error: return type 'class std::future<void>' is incomplete

Simon