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