1 /* Header file for gimple iterators. 2 Copyright (C) 2013-2018 Free Software Foundation, Inc. 3 4 This file is part of GCC. 5 6 GCC is free software; you can redistribute it and/or modify it under 7 the terms of the GNU General Public License as published by the Free 8 Software Foundation; either version 3, or (at your option) any later 9 version. 10 11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 12 WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GCC; see the file COPYING3. If not see 18 <http://www.gnu.org/licenses/>. */ 19 20 #ifndef GCC_GIMPLE_ITERATOR_H 21 #define GCC_GIMPLE_ITERATOR_H 22 23 /* Iterator object for GIMPLE statement sequences. */ 24 25 struct gimple_stmt_iterator 26 { 27 /* Sequence node holding the current statement. */ 28 gimple_seq_node ptr; 29 30 /* Sequence and basic block holding the statement. These fields 31 are necessary to handle edge cases such as when statement is 32 added to an empty basic block or when the last statement of a 33 block/sequence is removed. */ 34 gimple_seq *seq; 35 basic_block bb; 36 }; 37 38 /* Iterator over GIMPLE_PHI statements. */ 39 struct gphi_iterator : public gimple_stmt_iterator 40 { 41 gphi *phi () const 42 { 43 return as_a <gphi *> (ptr); 44 } 45 }; 46 47 enum gsi_iterator_update 48 { 49 GSI_NEW_STMT, /* Only valid when single statement is added, move 50 iterator to it. */ 51 GSI_SAME_STMT, /* Leave the iterator at the same statement. */ 52 GSI_CONTINUE_LINKING /* Move iterator to whatever position is suitable 53 for linking other statements in the same 54 direction. */ 55 }; 56 57 extern void gsi_insert_seq_before_without_update (gimple_stmt_iterator *, 58 gimple_seq, 59 enum gsi_iterator_update); 60 extern void gsi_insert_seq_before (gimple_stmt_iterator *, gimple_seq, 61 enum gsi_iterator_update); 62 extern void gsi_insert_seq_after_without_update (gimple_stmt_iterator *, 63 gimple_seq, 64 enum gsi_iterator_update); 65 extern void gsi_insert_seq_after (gimple_stmt_iterator *, gimple_seq, 66 enum gsi_iterator_update); 67 extern gimple_seq gsi_split_seq_after (gimple_stmt_iterator); 68 extern void gsi_set_stmt (gimple_stmt_iterator *, gimple *); 69 extern void gsi_split_seq_before (gimple_stmt_iterator *, gimple_seq *); 70 extern bool gsi_replace (gimple_stmt_iterator *, gimple *, bool); 71 extern void gsi_replace_with_seq (gimple_stmt_iterator *, gimple_seq, bool); 72 extern void gsi_insert_before_without_update (gimple_stmt_iterator *, gimple *, 73 enum gsi_iterator_update); 74 extern void gsi_insert_before (gimple_stmt_iterator *, gimple *, 75 enum gsi_iterator_update); 76 extern void gsi_insert_after_without_update (gimple_stmt_iterator *, gimple *, 77 enum gsi_iterator_update); 78 extern void gsi_insert_after (gimple_stmt_iterator *, gimple *, 79 enum gsi_iterator_update); 80 extern bool gsi_remove (gimple_stmt_iterator *, bool); 81 extern gimple_stmt_iterator gsi_for_stmt (gimple *); 82 extern gphi_iterator gsi_for_phi (gphi *); 83 extern void gsi_move_after (gimple_stmt_iterator *, gimple_stmt_iterator *); 84 extern void gsi_move_before (gimple_stmt_iterator *, gimple_stmt_iterator *); 85 extern void gsi_move_to_bb_end (gimple_stmt_iterator *, basic_block); 86 extern void gsi_insert_on_edge (edge, gimple *); 87 extern void gsi_insert_seq_on_edge (edge, gimple_seq); 88 extern basic_block gsi_insert_on_edge_immediate (edge, gimple *); 89 extern basic_block gsi_insert_seq_on_edge_immediate (edge, gimple_seq); 90 extern void gsi_commit_edge_inserts (void); 91 extern void gsi_commit_one_edge_insert (edge, basic_block *); 92 extern gphi_iterator gsi_start_phis (basic_block); 93 extern void update_modified_stmts (gimple_seq); 94 95 /* Return a new iterator pointing to GIMPLE_SEQ's first statement. */ 96 97 static inline gimple_stmt_iterator 98 gsi_start_1 (gimple_seq *seq) 99 { 100 gimple_stmt_iterator i; 101 102 i.ptr = gimple_seq_first (*seq); 103 i.seq = seq; 104 i.bb = i.ptr ? gimple_bb (i.ptr) : NULL; 105 106 return i; 107 } 108 109 #define gsi_start(x) gsi_start_1 (&(x)) 110 111 static inline gimple_stmt_iterator 112 gsi_none (void) 113 { 114 gimple_stmt_iterator i; 115 i.ptr = NULL; 116 i.seq = NULL; 117 i.bb = NULL; 118 return i; 119 } 120 121 /* Return a new iterator pointing to the first statement in basic block BB. */ 122 123 static inline gimple_stmt_iterator 124 gsi_start_bb (basic_block bb) 125 { 126 gimple_stmt_iterator i; 127 gimple_seq *seq; 128 129 seq = bb_seq_addr (bb); 130 i.ptr = gimple_seq_first (*seq); 131 i.seq = seq; 132 i.bb = bb; 133 134 return i; 135 } 136 137 gimple_stmt_iterator gsi_start_edge (edge e); 138 139 /* Return a new iterator initially pointing to GIMPLE_SEQ's last statement. */ 140 141 static inline gimple_stmt_iterator 142 gsi_last_1 (gimple_seq *seq) 143 { 144 gimple_stmt_iterator i; 145 146 i.ptr = gimple_seq_last (*seq); 147 i.seq = seq; 148 i.bb = i.ptr ? gimple_bb (i.ptr) : NULL; 149 150 return i; 151 } 152 153 #define gsi_last(x) gsi_last_1 (&(x)) 154 155 /* Return a new iterator pointing to the last statement in basic block BB. */ 156 157 static inline gimple_stmt_iterator 158 gsi_last_bb (basic_block bb) 159 { 160 gimple_stmt_iterator i; 161 gimple_seq *seq; 162 163 seq = bb_seq_addr (bb); 164 i.ptr = gimple_seq_last (*seq); 165 i.seq = seq; 166 i.bb = bb; 167 168 return i; 169 } 170 171 /* Return true if I is at the end of its sequence. */ 172 173 static inline bool 174 gsi_end_p (gimple_stmt_iterator i) 175 { 176 return i.ptr == NULL; 177 } 178 179 /* Return true if I is one statement before the end of its sequence. */ 180 181 static inline bool 182 gsi_one_before_end_p (gimple_stmt_iterator i) 183 { 184 return i.ptr != NULL && i.ptr->next == NULL; 185 } 186 187 /* Advance the iterator to the next gimple statement. */ 188 189 static inline void 190 gsi_next (gimple_stmt_iterator *i) 191 { 192 i->ptr = i->ptr->next; 193 } 194 195 /* Advance the iterator to the previous gimple statement. */ 196 197 static inline void 198 gsi_prev (gimple_stmt_iterator *i) 199 { 200 gimple *prev = i->ptr->prev; 201 if (prev->next) 202 i->ptr = prev; 203 else 204 i->ptr = NULL; 205 } 206 207 /* Return the current stmt. */ 208 209 static inline gimple * 210 gsi_stmt (gimple_stmt_iterator i) 211 { 212 return i.ptr; 213 } 214 215 /* Return a block statement iterator that points to the first 216 non-label statement in block BB. */ 217 218 static inline gimple_stmt_iterator 219 gsi_after_labels (basic_block bb) 220 { 221 gimple_stmt_iterator gsi = gsi_start_bb (bb); 222 223 for (; !gsi_end_p (gsi); ) 224 { 225 if (gimple_code (gsi_stmt (gsi)) == GIMPLE_LABEL) 226 gsi_next (&gsi); 227 else 228 break; 229 } 230 231 return gsi; 232 } 233 234 /* Advance the iterator to the next non-debug gimple statement. */ 235 236 static inline void 237 gsi_next_nondebug (gimple_stmt_iterator *i) 238 { 239 do 240 { 241 gsi_next (i); 242 } 243 while (!gsi_end_p (*i) && is_gimple_debug (gsi_stmt (*i))); 244 } 245 246 /* Advance the iterator to the previous non-debug gimple statement. */ 247 248 static inline void 249 gsi_prev_nondebug (gimple_stmt_iterator *i) 250 { 251 do 252 { 253 gsi_prev (i); 254 } 255 while (!gsi_end_p (*i) && is_gimple_debug (gsi_stmt (*i))); 256 } 257 258 /* Return a new iterator pointing to the first non-debug statement in 259 SEQ. */ 260 261 static inline gimple_stmt_iterator 262 gsi_start_nondebug (gimple_seq seq) 263 { 264 gimple_stmt_iterator gsi = gsi_start (seq); 265 if (!gsi_end_p (gsi) && is_gimple_debug (gsi_stmt (gsi))) 266 gsi_next_nondebug (&gsi); 267 268 return gsi; 269 } 270 271 /* Return a new iterator pointing to the first non-debug statement in 272 basic block BB. */ 273 274 static inline gimple_stmt_iterator 275 gsi_start_nondebug_bb (basic_block bb) 276 { 277 gimple_stmt_iterator i = gsi_start_bb (bb); 278 279 if (!gsi_end_p (i) && is_gimple_debug (gsi_stmt (i))) 280 gsi_next_nondebug (&i); 281 282 return i; 283 } 284 285 /* Return a new iterator pointing to the first non-debug non-label statement in 286 basic block BB. */ 287 288 static inline gimple_stmt_iterator 289 gsi_start_nondebug_after_labels_bb (basic_block bb) 290 { 291 gimple_stmt_iterator i = gsi_after_labels (bb); 292 293 if (!gsi_end_p (i) && is_gimple_debug (gsi_stmt (i))) 294 gsi_next_nondebug (&i); 295 296 return i; 297 } 298 299 /* Return a new iterator pointing to the last non-debug statement in 300 basic block BB. */ 301 302 static inline gimple_stmt_iterator 303 gsi_last_nondebug_bb (basic_block bb) 304 { 305 gimple_stmt_iterator i = gsi_last_bb (bb); 306 307 if (!gsi_end_p (i) && is_gimple_debug (gsi_stmt (i))) 308 gsi_prev_nondebug (&i); 309 310 return i; 311 } 312 313 /* Return true if I is followed only by debug statements in its 314 sequence. */ 315 316 static inline bool 317 gsi_one_nondebug_before_end_p (gimple_stmt_iterator i) 318 { 319 if (gsi_one_before_end_p (i)) 320 return true; 321 if (gsi_end_p (i)) 322 return false; 323 gsi_next_nondebug (&i); 324 return gsi_end_p (i); 325 } 326 327 /* Iterates I statement iterator to the next non-virtual statement. */ 328 329 static inline void 330 gsi_next_nonvirtual_phi (gphi_iterator *i) 331 { 332 gphi *phi; 333 334 if (gsi_end_p (*i)) 335 return; 336 337 phi = i->phi (); 338 gcc_assert (phi != NULL); 339 340 while (virtual_operand_p (gimple_phi_result (phi))) 341 { 342 gsi_next (i); 343 344 if (gsi_end_p (*i)) 345 return; 346 347 phi = i->phi (); 348 } 349 } 350 351 /* Return the basic block associated with this iterator. */ 352 353 static inline basic_block 354 gsi_bb (gimple_stmt_iterator i) 355 { 356 return i.bb; 357 } 358 359 /* Return the sequence associated with this iterator. */ 360 361 static inline gimple_seq 362 gsi_seq (gimple_stmt_iterator i) 363 { 364 return *i.seq; 365 } 366 367 /* Determine whether SEQ is a nondebug singleton. */ 368 369 static inline bool 370 gimple_seq_nondebug_singleton_p (gimple_seq seq) 371 { 372 gimple_stmt_iterator gsi; 373 374 /* Find a nondebug gimple. */ 375 gsi.ptr = gimple_seq_first (seq); 376 gsi.seq = &seq; 377 gsi.bb = NULL; 378 while (!gsi_end_p (gsi) 379 && is_gimple_debug (gsi_stmt (gsi))) 380 gsi_next (&gsi); 381 382 /* No nondebug gimple found, not a singleton. */ 383 if (gsi_end_p (gsi)) 384 return false; 385 386 /* Find a next nondebug gimple. */ 387 gsi_next (&gsi); 388 while (!gsi_end_p (gsi) 389 && is_gimple_debug (gsi_stmt (gsi))) 390 gsi_next (&gsi); 391 392 /* Only a singleton if there's no next nondebug gimple. */ 393 return gsi_end_p (gsi); 394 } 395 396 #endif /* GCC_GIMPLE_ITERATOR_H */ 397