| /* 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 */ |