blob: 6700f5593b9101f5e6decfd4aa46d6da207c7e19 [file] [log] [blame]
/* 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/>. */
#ifndef THREAD_ITER_H
#define THREAD_ITER_H
#include "gdbsupport/filtered-iterator.h"
#include "gdbsupport/iterator-range.h"
#include "gdbsupport/next-iterator.h"
#include "gdbsupport/reference-to-pointer-iterator.h"
#include "gdbsupport/safe-iterator.h"
/* A forward iterator that iterates over a given inferior's
threads. */
using inf_threads_iterator
= reference_to_pointer_iterator<intrusive_list<thread_info>::iterator>;
/* A forward iterator that iterates over all threads of all
inferiors. */
class all_threads_iterator
{
public:
typedef all_threads_iterator self_type;
typedef struct thread_info *value_type;
typedef struct thread_info *&reference;
typedef struct thread_info **pointer;
typedef std::forward_iterator_tag iterator_category;
typedef int difference_type;
/* Tag type. */
struct begin_t {};
/* Create an iterator that points to the first thread of the first
inferior. */
explicit all_threads_iterator (begin_t);
/* Create a one-past-end iterator. */
all_threads_iterator ()
: m_thr (nullptr)
{}
thread_info *operator* () const { return m_thr; }
all_threads_iterator &operator++ ()
{
advance ();
return *this;
}
bool operator== (const all_threads_iterator &other) const
{ return m_thr == other.m_thr; }
bool operator!= (const all_threads_iterator &other) const
{ return m_thr != other.m_thr; }
private:
/* Advance to the next thread. */
void advance ();
private:
/* The current inferior and thread. M_THR is NULL if we reached the
end of the threads list of the last inferior. */
inferior *m_inf;
thread_info *m_thr;
};
/* Iterate over all threads that match a given PTID. */
class all_matching_threads_iterator
{
public:
typedef all_matching_threads_iterator self_type;
typedef struct thread_info *value_type;
typedef struct thread_info *&reference;
typedef struct thread_info **pointer;
typedef std::forward_iterator_tag iterator_category;
typedef int difference_type;
/* Creates an iterator that iterates over all threads that match
FILTER_PTID. */
all_matching_threads_iterator (process_stratum_target *filter_target,
ptid_t filter_ptid);
/* Create a one-past-end iterator. */
all_matching_threads_iterator () = default;
thread_info *operator* () const { return m_thr; }
all_matching_threads_iterator &operator++ ()
{
advance ();
return *this;
}
bool operator== (const all_matching_threads_iterator &other) const
{ return m_thr == other.m_thr; }
bool operator!= (const all_matching_threads_iterator &other) const
{ return m_thr != other.m_thr; }
private:
/* Advance to next thread, skipping filtered threads. */
void advance ();
/* True if M_INF has the process target M_FILTER_TARGET. */
bool m_inf_matches ();
private:
enum class mode
{
/* All threads, possibly filtered down to a single target. */
ALL_THREADS,
/* All threads of the given inferior. */
ALL_THREADS_OF_INFERIOR,
/* A specific thread. */
SINGLE_THREAD,
} m_mode;
/* The current inferior. */
inferior *m_inf = nullptr;
/* The current thread. */
thread_info *m_thr = nullptr;
/* The target we filter on (may be nullptr). */
process_stratum_target *m_filter_target;
};
/* Filter for filtered_iterator. Filters out exited threads. */
struct non_exited_thread_filter
{
bool operator() (struct thread_info *thr) const
{
return thr->state != THREAD_EXITED;
}
};
/* Iterate over all non-exited threads that match a given PTID. */
using all_non_exited_threads_iterator
= filtered_iterator<all_matching_threads_iterator, non_exited_thread_filter>;
/* Iterate over all non-exited threads of an inferior. */
using inf_non_exited_threads_iterator
= filtered_iterator<inf_threads_iterator, non_exited_thread_filter>;
/* Iterate over all threads of all inferiors, safely. */
using all_threads_safe_iterator
= basic_safe_iterator<all_threads_iterator>;
/* Iterate over all threads of an inferior, safely. */
using safe_inf_threads_iterator
= basic_safe_iterator<inf_threads_iterator>;
/* A range adapter that makes it possible to iterate over all threads
of an inferior with range-for. */
using inf_threads_range = iterator_range<inf_threads_iterator>;
/* A range adapter that makes it possible to iterate over all
non-exited threads of an inferior with range-for. */
using inf_non_exited_threads_range
= iterator_range<inf_non_exited_threads_iterator>;
/* A range adapter that makes it possible to iterate over all threads
of an inferior with range-for, safely. */
using safe_inf_threads_range = iterator_range<safe_inf_threads_iterator>;
/* A range adapter that makes it possible to iterate over all threads
with range-for "safely". I.e., it is safe to delete the
currently-iterated thread. */
using all_threads_safe_range = iterator_range<all_threads_safe_iterator>;
/* A range adapter that makes it possible to iterate over all threads
that match a PTID filter with range-for. */
struct all_matching_threads_range
{
public:
all_matching_threads_range (process_stratum_target *filter_target,
ptid_t filter_ptid)
: m_filter_target (filter_target), m_filter_ptid (filter_ptid)
{}
all_matching_threads_range ()
: m_filter_target (nullptr), m_filter_ptid (minus_one_ptid)
{}
all_matching_threads_iterator begin () const
{ return all_matching_threads_iterator (m_filter_target, m_filter_ptid); }
all_matching_threads_iterator end () const
{ return all_matching_threads_iterator (); }
private:
/* The filter. */
process_stratum_target *m_filter_target;
ptid_t m_filter_ptid;
};
/* A range adapter that makes it possible to iterate over all
non-exited threads of all inferiors, with range-for.
Threads/inferiors that do not match FILTER_PTID are filtered
out. */
class all_non_exited_threads_range
{
public:
all_non_exited_threads_range (process_stratum_target *filter_target,
ptid_t filter_ptid)
: m_filter_target (filter_target), m_filter_ptid (filter_ptid)
{}
all_non_exited_threads_range ()
: m_filter_target (nullptr), m_filter_ptid (minus_one_ptid)
{}
all_non_exited_threads_iterator begin () const
{ return all_non_exited_threads_iterator (m_filter_target, m_filter_ptid); }
all_non_exited_threads_iterator end () const
{ return all_non_exited_threads_iterator (); }
private:
process_stratum_target *m_filter_target;
ptid_t m_filter_ptid;
};
#endif /* THREAD_ITER_H */