1 /* Thread iterators and ranges for GDB, the GNU debugger. 2 Copyright (C) 2018-2020 Free Software Foundation, Inc. 3 4 This file is part of GDB. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 18 19 #ifndef THREAD_ITER_H 20 #define THREAD_ITER_H 21 22 #include "gdbsupport/filtered-iterator.h" 23 #include "gdbsupport/next-iterator.h" 24 #include "gdbsupport/safe-iterator.h" 25 26 /* A forward iterator that iterates over a given inferior's 27 threads. */ 28 29 using inf_threads_iterator = next_iterator<thread_info>; 30 31 /* A forward iterator that iterates over all threads of all 32 inferiors. */ 33 34 class all_threads_iterator 35 { 36 public: 37 typedef all_threads_iterator self_type; 38 typedef struct thread_info *value_type; 39 typedef struct thread_info *&reference; 40 typedef struct thread_info **pointer; 41 typedef std::forward_iterator_tag iterator_category; 42 typedef int difference_type; 43 44 /* Tag type. */ 45 struct begin_t {}; 46 47 /* Create an iterator that points to the first thread of the first 48 inferior. */ 49 explicit all_threads_iterator (begin_t); 50 51 /* Create a one-past-end iterator. */ 52 all_threads_iterator () 53 : m_thr (nullptr) 54 {} 55 56 thread_info *operator* () const { return m_thr; } 57 58 all_threads_iterator &operator++ () 59 { 60 advance (); 61 return *this; 62 } 63 64 bool operator== (const all_threads_iterator &other) const 65 { return m_thr == other.m_thr; } 66 67 bool operator!= (const all_threads_iterator &other) const 68 { return m_thr != other.m_thr; } 69 70 private: 71 /* Advance to the next thread. */ 72 void advance (); 73 74 private: 75 /* The current inferior and thread. M_THR is NULL if we reached the 76 end of the threads list of the last inferior. */ 77 inferior *m_inf; 78 thread_info *m_thr; 79 }; 80 81 /* Iterate over all threads that match a given PTID. */ 82 83 class all_matching_threads_iterator 84 { 85 public: 86 typedef all_matching_threads_iterator self_type; 87 typedef struct thread_info *value_type; 88 typedef struct thread_info *&reference; 89 typedef struct thread_info **pointer; 90 typedef std::forward_iterator_tag iterator_category; 91 typedef int difference_type; 92 93 /* Creates an iterator that iterates over all threads that match 94 FILTER_PTID. */ 95 all_matching_threads_iterator (process_stratum_target *filter_target, 96 ptid_t filter_ptid); 97 98 /* Create a one-past-end iterator. */ 99 all_matching_threads_iterator () 100 : m_inf (nullptr), 101 m_thr (nullptr), 102 m_filter_target (nullptr), 103 m_filter_ptid (minus_one_ptid) 104 {} 105 106 thread_info *operator* () const { return m_thr; } 107 108 all_matching_threads_iterator &operator++ () 109 { 110 advance (); 111 return *this; 112 } 113 114 bool operator== (const all_matching_threads_iterator &other) const 115 { return m_thr == other.m_thr; } 116 117 bool operator!= (const all_matching_threads_iterator &other) const 118 { return m_thr != other.m_thr; } 119 120 private: 121 /* Advance to next thread, skipping filtered threads. */ 122 void advance (); 123 124 /* True if M_INF matches the process identified by 125 M_FILTER_PTID. */ 126 bool m_inf_matches (); 127 128 private: 129 /* The current inferior. */ 130 inferior *m_inf; 131 132 /* The current thread. */ 133 thread_info *m_thr; 134 135 /* The filter. */ 136 process_stratum_target *m_filter_target; 137 ptid_t m_filter_ptid; 138 }; 139 140 /* Filter for filtered_iterator. Filters out exited threads. */ 141 142 struct non_exited_thread_filter 143 { 144 bool operator() (struct thread_info *thr) const 145 { 146 return thr->state != THREAD_EXITED; 147 } 148 }; 149 150 /* Iterate over all non-exited threads that match a given PTID. */ 151 152 using all_non_exited_threads_iterator 153 = filtered_iterator<all_matching_threads_iterator, non_exited_thread_filter>; 154 155 /* Iterate over all non-exited threads of an inferior. */ 156 157 using inf_non_exited_threads_iterator 158 = filtered_iterator<inf_threads_iterator, non_exited_thread_filter>; 159 160 /* Iterate over all threads of all inferiors, safely. */ 161 162 using all_threads_safe_iterator 163 = basic_safe_iterator<all_threads_iterator>; 164 165 /* Iterate over all threads of an inferior, safely. */ 166 167 using safe_inf_threads_iterator 168 = basic_safe_iterator<inf_threads_iterator>; 169 170 /* A range adapter that makes it possible to iterate over all threads 171 of an inferior with range-for. */ 172 173 using inf_threads_range 174 = next_adapter<thread_info, inf_threads_iterator>; 175 176 /* A range adapter that makes it possible to iterate over all 177 non-exited threads of an inferior with range-for. */ 178 179 using inf_non_exited_threads_range 180 = next_adapter<thread_info, inf_non_exited_threads_iterator>; 181 182 /* A range adapter that makes it possible to iterate over all threads 183 of an inferior with range-for, safely. */ 184 185 using safe_inf_threads_range 186 = next_adapter<thread_info, safe_inf_threads_iterator>; 187 188 /* A range adapter that makes it possible to iterate over all threads 189 of all inferiors with range-for. */ 190 191 struct all_threads_range 192 { 193 all_threads_iterator begin () const 194 { return all_threads_iterator (all_threads_iterator::begin_t {}); } 195 all_threads_iterator end () const 196 { return all_threads_iterator (); } 197 }; 198 199 /* A range adapter that makes it possible to iterate over all threads 200 with range-for "safely". I.e., it is safe to delete the 201 currently-iterated thread. */ 202 203 struct all_threads_safe_range 204 { 205 all_threads_safe_iterator begin () const 206 { return all_threads_safe_iterator (all_threads_iterator::begin_t {}); } 207 all_threads_safe_iterator end () const 208 { return all_threads_safe_iterator (); } 209 }; 210 211 /* A range adapter that makes it possible to iterate over all threads 212 that match a PTID filter with range-for. */ 213 214 struct all_matching_threads_range 215 { 216 public: 217 all_matching_threads_range (process_stratum_target *filter_target, 218 ptid_t filter_ptid) 219 : m_filter_target (filter_target), m_filter_ptid (filter_ptid) 220 {} 221 all_matching_threads_range () 222 : m_filter_target (nullptr), m_filter_ptid (minus_one_ptid) 223 {} 224 225 all_matching_threads_iterator begin () const 226 { return all_matching_threads_iterator (m_filter_target, m_filter_ptid); } 227 all_matching_threads_iterator end () const 228 { return all_matching_threads_iterator (); } 229 230 private: 231 /* The filter. */ 232 process_stratum_target *m_filter_target; 233 ptid_t m_filter_ptid; 234 }; 235 236 /* A range adapter that makes it possible to iterate over all 237 non-exited threads of all inferiors, with range-for. 238 Threads/inferiors that do not match FILTER_PTID are filtered 239 out. */ 240 241 class all_non_exited_threads_range 242 { 243 public: 244 all_non_exited_threads_range (process_stratum_target *filter_target, 245 ptid_t filter_ptid) 246 : m_filter_target (filter_target), m_filter_ptid (filter_ptid) 247 {} 248 249 all_non_exited_threads_range () 250 : m_filter_target (nullptr), m_filter_ptid (minus_one_ptid) 251 {} 252 253 all_non_exited_threads_iterator begin () const 254 { return all_non_exited_threads_iterator (m_filter_target, m_filter_ptid); } 255 all_non_exited_threads_iterator end () const 256 { return all_non_exited_threads_iterator (); } 257 258 private: 259 process_stratum_target *m_filter_target; 260 ptid_t m_filter_ptid; 261 }; 262 263 #endif /* THREAD_ITER_H */ 264