1/* Header file for gimple iterators. 2 Copyright (C) 2013-2015 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 gphi_iterator gsi_for_phi (gphi *); 83extern void gsi_move_after (gimple_stmt_iterator *, gimple_stmt_iterator *); 84extern void gsi_move_before (gimple_stmt_iterator *, gimple_stmt_iterator *); 85extern void gsi_move_to_bb_end (gimple_stmt_iterator *, basic_block); 86extern void gsi_insert_on_edge (edge, gimple); 87extern void gsi_insert_seq_on_edge (edge, gimple_seq); 88extern basic_block gsi_insert_on_edge_immediate (edge, gimple); 89extern basic_block gsi_insert_seq_on_edge_immediate (edge, gimple_seq); 90extern void gsi_commit_edge_inserts (void); 91extern void gsi_commit_one_edge_insert (edge, basic_block *); 92extern gphi_iterator gsi_start_phis (basic_block); 93 94/* Return a new iterator pointing to GIMPLE_SEQ's first statement. */ 95 96static inline gimple_stmt_iterator 97gsi_start_1 (gimple_seq *seq) 98{ 99 gimple_stmt_iterator i; 100 101 i.ptr = gimple_seq_first (*seq); 102 i.seq = seq; 103 i.bb = i.ptr ? gimple_bb (i.ptr) : NULL; 104 105 return i; 106} 107 108#define gsi_start(x) gsi_start_1 (&(x)) 109 110static inline gimple_stmt_iterator 111gsi_none (void) 112{ 113 gimple_stmt_iterator i; 114 i.ptr = NULL; 115 i.seq = NULL; 116 i.bb = NULL; 117 return i; 118} 119 120/* Return a new iterator pointing to the first statement in basic block BB. */ 121 122static inline gimple_stmt_iterator 123gsi_start_bb (basic_block bb) 124{ 125 gimple_stmt_iterator i; 126 gimple_seq *seq; 127 128 seq = bb_seq_addr (bb); 129 i.ptr = gimple_seq_first (*seq); 130 i.seq = seq; 131 i.bb = bb; 132 133 return i; 134} 135 136gimple_stmt_iterator gsi_start_edge (edge e); 137 138/* Return a new iterator initially pointing to GIMPLE_SEQ's last statement. */ 139 140static inline gimple_stmt_iterator 141gsi_last_1 (gimple_seq *seq) 142{ 143 gimple_stmt_iterator i; 144 145 i.ptr = gimple_seq_last (*seq); 146 i.seq = seq; 147 i.bb = i.ptr ? gimple_bb (i.ptr) : NULL; 148 149 return i; 150} 151 152#define gsi_last(x) gsi_last_1 (&(x)) 153 154/* Return a new iterator pointing to the last statement in basic block BB. */ 155 156static inline gimple_stmt_iterator 157gsi_last_bb (basic_block bb) 158{ 159 gimple_stmt_iterator i; 160 gimple_seq *seq; 161 162 seq = bb_seq_addr (bb); 163 i.ptr = gimple_seq_last (*seq); 164 i.seq = seq; 165 i.bb = bb; 166 167 return i; 168} 169 170/* Return true if I is at the end of its sequence. */ 171 172static inline bool 173gsi_end_p (gimple_stmt_iterator i) 174{ 175 return i.ptr == NULL; 176} 177 178/* Return true if I is one statement before the end of its sequence. */ 179 180static inline bool 181gsi_one_before_end_p (gimple_stmt_iterator i) 182{ 183 return i.ptr != NULL && i.ptr->next == NULL; 184} 185 186/* Advance the iterator to the next gimple statement. */ 187 188static inline void 189gsi_next (gimple_stmt_iterator *i) 190{ 191 i->ptr = i->ptr->next; 192} 193 194/* Advance the iterator to the previous gimple statement. */ 195 196static inline void 197gsi_prev (gimple_stmt_iterator *i) 198{ 199 gimple prev = i->ptr->prev; 200 if (prev->next) 201 i->ptr = prev; 202 else 203 i->ptr = NULL; 204} 205 206/* Return the current stmt. */ 207 208static inline gimple 209gsi_stmt (gimple_stmt_iterator i) 210{ 211 return i.ptr; 212} 213 214/* Return a new iterator pointing to the first non-debug statement 215 in basic block BB. */ 216 217static inline gimple_stmt_iterator 218gsi_start_bb_nondebug (basic_block bb) 219{ 220 gimple_stmt_iterator gsi = gsi_start_bb (bb); 221 while (!gsi_end_p (gsi) && is_gimple_debug (gsi_stmt (gsi))) 222 gsi_next (&gsi); 223 224 return gsi; 225} 226 227/* Return a block statement iterator that points to the first non-label 228 statement in block BB. */ 229 230static inline gimple_stmt_iterator 231gsi_after_labels (basic_block bb) 232{ 233 gimple_stmt_iterator gsi = gsi_start_bb (bb); 234 235 while (!gsi_end_p (gsi) && gimple_code (gsi_stmt (gsi)) == GIMPLE_LABEL) 236 gsi_next (&gsi); 237 238 return gsi; 239} 240 241/* Advance the iterator to the next non-debug gimple statement. */ 242 243static inline void 244gsi_next_nondebug (gimple_stmt_iterator *i) 245{ 246 do 247 { 248 gsi_next (i); 249 } 250 while (!gsi_end_p (*i) && is_gimple_debug (gsi_stmt (*i))); 251} 252 253/* Advance the iterator to the previous non-debug gimple statement. */ 254 255static inline void 256gsi_prev_nondebug (gimple_stmt_iterator *i) 257{ 258 do 259 { 260 gsi_prev (i); 261 } 262 while (!gsi_end_p (*i) && is_gimple_debug (gsi_stmt (*i))); 263} 264 265/* Return a new iterator pointing to the first non-debug statement in 266 basic block BB. */ 267 268static inline gimple_stmt_iterator 269gsi_start_nondebug_bb (basic_block bb) 270{ 271 gimple_stmt_iterator i = gsi_start_bb (bb); 272 273 if (!gsi_end_p (i) && is_gimple_debug (gsi_stmt (i))) 274 gsi_next_nondebug (&i); 275 276 return i; 277} 278 279/* Return a new iterator pointing to the first non-debug non-label statement in 280 basic block BB. */ 281 282static inline gimple_stmt_iterator 283gsi_start_nondebug_after_labels_bb (basic_block bb) 284{ 285 gimple_stmt_iterator i = gsi_after_labels (bb); 286 287 if (!gsi_end_p (i) && is_gimple_debug (gsi_stmt (i))) 288 gsi_next_nondebug (&i); 289 290 return i; 291} 292 293/* Return a new iterator pointing to the last non-debug statement in 294 basic block BB. */ 295 296static inline gimple_stmt_iterator 297gsi_last_nondebug_bb (basic_block bb) 298{ 299 gimple_stmt_iterator i = gsi_last_bb (bb); 300 301 if (!gsi_end_p (i) && is_gimple_debug (gsi_stmt (i))) 302 gsi_prev_nondebug (&i); 303 304 return i; 305} 306 307/* Iterates I statement iterator to the next non-virtual statement. */ 308 309static inline void 310gsi_next_nonvirtual_phi (gphi_iterator *i) 311{ 312 gphi *phi; 313 314 if (gsi_end_p (*i)) 315 return; 316 317 phi = i->phi (); 318 gcc_assert (phi != NULL); 319 320 while (virtual_operand_p (gimple_phi_result (phi))) 321 { 322 gsi_next (i); 323 324 if (gsi_end_p (*i)) 325 return; 326 327 phi = i->phi (); 328 } 329} 330 331/* Return the basic block associated with this iterator. */ 332 333static inline basic_block 334gsi_bb (gimple_stmt_iterator i) 335{ 336 return i.bb; 337} 338 339/* Return the sequence associated with this iterator. */ 340 341static inline gimple_seq 342gsi_seq (gimple_stmt_iterator i) 343{ 344 return *i.seq; 345} 346 347#endif /* GCC_GIMPLE_ITERATOR_H */ 348