binutils-gdb/gdb/thread-iter.h

257 lines
7.0 KiB
C++

/* Thread iterators and ranges for GDB, the GNU debugger.
Copyright (C) 2018-2019 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 "common/filtered-iterator.h"
#include "common/next-iterator.h"
#include "common/safe-iterator.h"
/* A forward iterator that iterates over a given inferior's
threads. */
using inf_threads_iterator = next_iterator<thread_info>;
/* 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. */
explicit all_matching_threads_iterator (ptid_t filter_ptid);
/* Create a one-past-end iterator. */
all_matching_threads_iterator ()
: m_inf (nullptr),
m_thr (nullptr),
m_filter_ptid (minus_one_ptid)
{}
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 matches the process identified by
M_FILTER_PTID. */
bool m_inf_matches ();
private:
/* The current inferior. */
inferior *m_inf;
/* The current thread. */
thread_info *m_thr;
/* The filter. */
ptid_t m_filter_ptid;
};
/* 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
= next_adapter<thread_info, 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
= next_adapter<thread_info, 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
= next_adapter<thread_info, safe_inf_threads_iterator>;
/* A range adapter that makes it possible to iterate over all threads
of all inferiors with range-for. */
struct all_threads_range
{
all_threads_iterator begin () const
{ return all_threads_iterator (all_threads_iterator::begin_t {}); }
all_threads_iterator end () const
{ return all_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. */
struct all_threads_safe_range
{
all_threads_safe_iterator begin () const
{ return all_threads_safe_iterator (all_threads_iterator::begin_t {}); }
all_threads_safe_iterator end () const
{ return 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:
explicit all_matching_threads_range (ptid_t filter_ptid)
: m_filter_ptid (filter_ptid)
{}
all_matching_threads_range ()
: m_filter_ptid (minus_one_ptid)
{}
all_matching_threads_iterator begin () const
{ return all_matching_threads_iterator (m_filter_ptid); }
all_matching_threads_iterator end () const
{ return all_matching_threads_iterator (); }
private:
/* The filter. */
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:
explicit all_non_exited_threads_range (ptid_t filter_ptid)
: m_filter_ptid (filter_ptid)
{}
all_non_exited_threads_range ()
: m_filter_ptid (minus_one_ptid)
{}
all_non_exited_threads_iterator begin () const
{ return all_non_exited_threads_iterator (m_filter_ptid); }
all_non_exited_threads_iterator end () const
{ return all_non_exited_threads_iterator (); }
private:
ptid_t m_filter_ptid;
};
#endif /* THREAD_ITER_H */