gcc/gimple-iterator.h

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