08bdefb58b
Change inferior_list, the global list of inferiors, to use intrusive_list. I think most other changes are somewhat obvious fallouts from this change. There is a small change in behavior in scoped_mock_context. Before this patch, constructing a scoped_mock_context would replace the whole inferior list with only the new mock inferior. Tests using two scoped_mock_contexts therefore needed to manually link the two inferiors together, as the second scoped_mock_context would bump the first mock inferior from the thread list. With this patch, a scoped_mock_context adds its mock inferior to the inferior list on construction, and removes it on destruction. This means that tests run with mock inferiors in the inferior list in addition to any pre-existing inferiors (there is always at least one). There is no possible pid clash problem, since each scoped mock inferior uses its own process target, and pids are per process target. Co-Authored-By: Simon Marchi <simon.marchi@efficios.com> Change-Id: I7eb6a8f867d4dcf8b8cd2dcffd118f7270756018
146 lines
3.6 KiB
C
146 lines
3.6 KiB
C
/* Thread iterators and ranges for GDB, the GNU debugger.
|
|
|
|
Copyright (C) 2018-2021 Free Software Foundation, Inc.
|
|
|
|
This file is part of GDB.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
#include "defs.h"
|
|
#include "gdbthread.h"
|
|
#include "inferior.h"
|
|
|
|
/* See thread-iter.h. */
|
|
|
|
all_threads_iterator::all_threads_iterator (begin_t)
|
|
{
|
|
/* Advance M_INF/M_THR to the first thread's position. */
|
|
|
|
for (inferior &inf : inferior_list)
|
|
{
|
|
auto thr_iter = inf.thread_list.begin ();
|
|
if (thr_iter != inf.thread_list.end ())
|
|
{
|
|
m_inf = &inf;
|
|
m_thr = &*thr_iter;
|
|
return;
|
|
}
|
|
}
|
|
m_inf = nullptr;
|
|
m_thr = nullptr;
|
|
}
|
|
|
|
/* See thread-iter.h. */
|
|
|
|
void
|
|
all_threads_iterator::advance ()
|
|
{
|
|
intrusive_list<inferior>::iterator inf_iter (m_inf);
|
|
intrusive_list<thread_info>::iterator thr_iter (m_thr);
|
|
|
|
/* The loop below is written in the natural way as-if we'd always
|
|
start at the beginning of the inferior list. This fast forwards
|
|
the algorithm to the actual current position. */
|
|
goto start;
|
|
|
|
for (; inf_iter != inferior_list.end (); ++inf_iter)
|
|
{
|
|
m_inf = &*inf_iter;
|
|
thr_iter = m_inf->thread_list.begin ();
|
|
while (thr_iter != m_inf->thread_list.end ())
|
|
{
|
|
m_thr = &*thr_iter;
|
|
return;
|
|
start:
|
|
++thr_iter;
|
|
}
|
|
}
|
|
|
|
m_thr = nullptr;
|
|
}
|
|
|
|
/* See thread-iter.h. */
|
|
|
|
bool
|
|
all_matching_threads_iterator::m_inf_matches ()
|
|
{
|
|
return ((m_filter_target == nullptr
|
|
|| m_filter_target == m_inf->process_target ())
|
|
&& (m_filter_ptid == minus_one_ptid
|
|
|| m_filter_ptid.pid () == m_inf->pid));
|
|
}
|
|
|
|
/* See thread-iter.h. */
|
|
|
|
all_matching_threads_iterator::all_matching_threads_iterator
|
|
(process_stratum_target *filter_target, ptid_t filter_ptid)
|
|
: m_filter_target (filter_target),
|
|
m_filter_ptid (filter_ptid)
|
|
{
|
|
gdb_assert ((filter_target == nullptr && filter_ptid == minus_one_ptid)
|
|
|| filter_target->stratum () == process_stratum);
|
|
|
|
for (inferior &inf : inferior_list)
|
|
{
|
|
m_inf = &inf;
|
|
if (m_inf_matches ())
|
|
for (auto thr_iter = m_inf->thread_list.begin ();
|
|
thr_iter != m_inf->thread_list.end ();
|
|
++thr_iter)
|
|
{
|
|
if (thr_iter->ptid.matches (m_filter_ptid))
|
|
{
|
|
m_thr = &*thr_iter;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
m_thr = nullptr;
|
|
}
|
|
|
|
/* See thread-iter.h. */
|
|
|
|
void
|
|
all_matching_threads_iterator::advance ()
|
|
{
|
|
intrusive_list<inferior>::iterator inf_iter (m_inf);
|
|
intrusive_list<thread_info>::iterator thr_iter (m_thr);
|
|
|
|
/* The loop below is written in the natural way as-if we'd always
|
|
start at the beginning of the inferior list. This fast forwards
|
|
the algorithm to the actual current position. */
|
|
goto start;
|
|
|
|
for (; inf_iter != inferior_list.end (); ++inf_iter)
|
|
{
|
|
m_inf = &*inf_iter;
|
|
if (m_inf_matches ())
|
|
{
|
|
thr_iter = m_inf->thread_list.begin ();
|
|
while (thr_iter != m_inf->thread_list.end ())
|
|
{
|
|
if (thr_iter->ptid.matches (m_filter_ptid))
|
|
{
|
|
m_thr = &*thr_iter;
|
|
return;
|
|
}
|
|
start:
|
|
++thr_iter;
|
|
}
|
|
}
|
|
}
|
|
|
|
m_thr = nullptr;
|
|
}
|