gcc/gimple-iterator.h

   1 /* Header file for gimple iterators.
   2    Copyright (C) 2013-2024 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   gimple *operator * () const { return ptr; }
  28
  29   /* Sequence node holding the current statement.  */
  30   gimple_seq_node ptr;
  31
  32   /* Sequence and basic block holding the statement.  These fields
  33      are necessary to handle edge cases such as when statement is
  34      added to an empty basic block or when the last statement of a
  35      block/sequence is removed.  */
  36   gimple_seq *seq;
  37   basic_block bb;
  38 };
  39
  40 /* Iterator over GIMPLE_PHI statements.  */
  41 struct gphi_iterator : public gimple_stmt_iterator
  42 {
  43   gphi *operator * () const { return as_a <gphi *> (ptr); }
  44
  45   gphi *phi () const
  46   {
  47     return as_a <gphi *> (ptr);
  48   }
  49 };
  50
  51 enum gsi_iterator_update
  52 {
  53   GSI_NEW_STMT = 2,     /* Move the iterator to the first statement added.  */
  54   GSI_LAST_NEW_STMT,    /* Move the iterator to the last statement added.  */
  55   GSI_SAME_STMT,        /* Leave the iterator at the same statement.  */
  56   GSI_CONTINUE_LINKING  /* Move iterator to whatever position is suitable
  57                            for linking other statements in the same
  58                            direction.  */
  59 };
  60
  61 extern void gsi_insert_seq_before_without_update (gimple_stmt_iterator *,
  62                                                   gimple_seq,
  63                                                   enum gsi_iterator_update);
  64 extern void gsi_insert_seq_before (gimple_stmt_iterator *, gimple_seq,
  65                                    enum gsi_iterator_update);
  66 extern void gsi_insert_seq_after_without_update (gimple_stmt_iterator *,
  67                                                  gimple_seq,
  68                                                  enum gsi_iterator_update);
  69 extern void gsi_insert_seq_after (gimple_stmt_iterator *, gimple_seq,
  70                                   enum gsi_iterator_update);
  71 extern gimple_seq gsi_split_seq_after (gimple_stmt_iterator);
  72 extern void gsi_set_stmt (gimple_stmt_iterator *, gimple *);
  73 extern void gsi_split_seq_before (gimple_stmt_iterator *, gimple_seq *);
  74 extern bool gsi_replace (gimple_stmt_iterator *, gimple *, bool);
  75 extern void gsi_replace_with_seq (gimple_stmt_iterator *, gimple_seq, bool);
  76 extern void gsi_insert_before_without_update (gimple_stmt_iterator *, gimple *,
  77                                               enum gsi_iterator_update);
  78 extern void gsi_insert_before (gimple_stmt_iterator *, gimple *,
  79                                enum gsi_iterator_update);
  80 extern void gsi_insert_after_without_update (gimple_stmt_iterator *, gimple *,
  81                                              enum gsi_iterator_update);
  82 extern void gsi_insert_after (gimple_stmt_iterator *, gimple *,
  83                               enum gsi_iterator_update);
  84 extern bool gsi_remove (gimple_stmt_iterator *, bool);
  85 extern gimple_stmt_iterator gsi_for_stmt (gimple *);
  86 extern gimple_stmt_iterator gsi_for_stmt (gimple *, gimple_seq *);
  87 extern gphi_iterator gsi_for_phi (gphi *);
  88 extern void gsi_move_after (gimple_stmt_iterator *, gimple_stmt_iterator *);
  89 extern void gsi_move_before (gimple_stmt_iterator *, gimple_stmt_iterator *,
  90                              gsi_iterator_update = GSI_SAME_STMT);
  91 extern void gsi_move_to_bb_end (gimple_stmt_iterator *, basic_block);
  92 extern void gsi_insert_on_edge (edge, gimple *);
  93 extern void gsi_insert_seq_on_edge (edge, gimple_seq);
  94 extern basic_block gsi_insert_on_edge_immediate (edge, gimple *);
  95 extern basic_block gsi_insert_seq_on_edge_immediate (edge, gimple_seq);
  96 extern void gsi_commit_edge_inserts (void);
  97 extern void gsi_commit_one_edge_insert (edge, basic_block *);
  98 extern gphi_iterator gsi_start_phis (basic_block);
  99 extern void update_modified_stmts (gimple_seq);
 100
 101 /* Return a new iterator pointing to GIMPLE_SEQ's first statement.  */
 102
 103 inline gimple_stmt_iterator
 104 gsi_start (gimple_seq &seq)
 105 {
 106   gimple_stmt_iterator i;
 107
 108   i.ptr = gimple_seq_first (seq);
 109   i.seq = &seq;
 110   i.bb = i.ptr ? gimple_bb (i.ptr) : NULL;
 111
 112   return i;
 113 }
 114
 115 inline gimple_stmt_iterator
 116 gsi_none (void)
 117 {
 118   gimple_stmt_iterator i;
 119   i.ptr = NULL;
 120   i.seq = NULL;
 121   i.bb = NULL;
 122   return i;
 123 }
 124
 125 /* Return a new iterator pointing to the first statement in basic block BB.  */
 126
 127 inline gimple_stmt_iterator
 128 gsi_start_bb (basic_block bb)
 129 {
 130   gimple_stmt_iterator i;
 131   gimple_seq *seq;
 132
 133   seq = bb_seq_addr (bb);
 134   i.ptr = gimple_seq_first (*seq);
 135   i.seq = seq;
 136   i.bb = bb;
 137
 138   return i;
 139 }
 140
 141 gimple_stmt_iterator gsi_start_edge (edge e);
 142
 143 /* Return a new iterator initially pointing to GIMPLE_SEQ's last statement.  */
 144
 145 inline gimple_stmt_iterator
 146 gsi_last (gimple_seq &seq)
 147 {
 148   gimple_stmt_iterator i;
 149
 150   i.ptr = gimple_seq_last (seq);
 151   i.seq = &seq;
 152   i.bb = i.ptr ? gimple_bb (i.ptr) : NULL;
 153
 154   return i;
 155 }
 156
 157 /* Return a new iterator pointing to the last statement in basic block BB.  */
 158
 159 inline gimple_stmt_iterator
 160 gsi_last_bb (basic_block bb)
 161 {
 162   gimple_stmt_iterator i;
 163   gimple_seq *seq;
 164
 165   seq = bb_seq_addr (bb);
 166   i.ptr = gimple_seq_last (*seq);
 167   i.seq = seq;
 168   i.bb = bb;
 169
 170   return i;
 171 }
 172
 173 /* Return a new iterator pointing to before the first statement or after
 174    last statement (depending on whether adding statements after it or before it)
 175    in a GIMPLE_SEQ.  */
 176
 177 inline gimple_stmt_iterator
 178 gsi_end (gimple_seq &seq)
 179 {
 180   gimple_stmt_iterator i;
 181   gimple *g = gimple_seq_last (seq);
 182
 183   i.ptr = NULL;
 184   i.seq = &seq;
 185   i.bb = g ? gimple_bb (g) : NULL;
 186
 187   return i;
 188 }
 189
 190 /* Return a new iterator pointing to before the first statement or after
 191    last statement (depending on whether adding statements after it or before it)
 192    in basic block BB.  */
 193
 194 inline gimple_stmt_iterator
 195 gsi_end_bb (basic_block bb)
 196 {
 197   gimple_stmt_iterator i;
 198   gimple_seq *seq;
 199
 200   seq = bb_seq_addr (bb);
 201   i.ptr = NULL;
 202   i.seq = seq;
 203   i.bb = bb;
 204
 205   return i;
 206 }
 207
 208 /* Return true if I is at the end of its sequence.  */
 209
 210 inline bool
 211 gsi_end_p (gimple_stmt_iterator i)
 212 {
 213   return i.ptr == NULL;
 214 }
 215
 216 /* Return true if I is one statement before the end of its sequence.  */
 217
 218 inline bool
 219 gsi_one_before_end_p (gimple_stmt_iterator i)
 220 {
 221   return i.ptr != NULL && i.ptr->next == NULL;
 222 }
 223
 224 /* Advance the iterator to the next gimple statement.  */
 225
 226 inline void
 227 gsi_next (gimple_stmt_iterator *i)
 228 {
 229   i->ptr = i->ptr->next;
 230 }
 231
 232 /* Advance the iterator to the previous gimple statement.  */
 233
 234 inline void
 235 gsi_prev (gimple_stmt_iterator *i)
 236 {
 237   gimple *prev = i->ptr->prev;
 238   if (prev->next)
 239     i->ptr = prev;
 240   else
 241     i->ptr = NULL;
 242 }
 243
 244 /* Return the current stmt.  */
 245
 246 inline gimple *
 247 gsi_stmt (gimple_stmt_iterator i)
 248 {
 249   return i.ptr;
 250 }
 251
 252 /* Return a block statement iterator that points to the first
 253    non-label statement in block BB.  */
 254
 255 inline gimple_stmt_iterator
 256 gsi_after_labels (basic_block bb)
 257 {
 258   gimple_stmt_iterator gsi = gsi_start_bb (bb);
 259
 260   for (; !gsi_end_p (gsi); )
 261     {
 262       if (gimple_code (gsi_stmt (gsi)) == GIMPLE_LABEL)
 263         gsi_next (&gsi);
 264       else
 265         break;
 266     }
 267
 268   return gsi;
 269 }
 270
 271 /* Return a statement iterator that points to the first
 272    non-label statement in sequence SEQ.  */
 273
 274 inline gimple_stmt_iterator
 275 gsi_after_labels (gimple_seq &seq)
 276 {
 277   gimple_stmt_iterator gsi = gsi_start (seq);
 278
 279   for (; !gsi_end_p (gsi); )
 280     {
 281       if (gimple_code (gsi_stmt (gsi)) == GIMPLE_LABEL)
 282         gsi_next (&gsi);
 283       else
 284         break;
 285     }
 286
 287   return gsi;
 288 }
 289
 290 /* Advance the iterator to the next non-debug gimple statement.  */
 291
 292 inline void
 293 gsi_next_nondebug (gimple_stmt_iterator *i)
 294 {
 295   do
 296     {
 297       gsi_next (i);
 298     }
 299   while (!gsi_end_p (*i) && is_gimple_debug (gsi_stmt (*i)));
 300 }
 301
 302 /* Advance the iterator to the previous non-debug gimple statement.  */
 303
 304 inline void
 305 gsi_prev_nondebug (gimple_stmt_iterator *i)
 306 {
 307   do
 308     {
 309       gsi_prev (i);
 310     }
 311   while (!gsi_end_p (*i) && is_gimple_debug (gsi_stmt (*i)));
 312 }
 313
 314 /* Return a new iterator pointing to the first non-debug statement in
 315    SEQ.  */
 316
 317 inline gimple_stmt_iterator
 318 gsi_start_nondebug (gimple_seq seq)
 319 {
 320   gimple_stmt_iterator gsi = gsi_start (seq);
 321   if (!gsi_end_p (gsi) && is_gimple_debug (gsi_stmt (gsi)))
 322     gsi_next_nondebug (&gsi);
 323
 324   return gsi;
 325 }
 326
 327 /* Return a new iterator pointing to the first non-debug statement in
 328    basic block BB.  */
 329
 330 inline gimple_stmt_iterator
 331 gsi_start_nondebug_bb (basic_block bb)
 332 {
 333   gimple_stmt_iterator i = gsi_start_bb (bb);
 334
 335   if (!gsi_end_p (i) && is_gimple_debug (gsi_stmt (i)))
 336     gsi_next_nondebug (&i);
 337
 338   return i;
 339 }
 340
 341 /* Return a new iterator pointing to the first non-debug non-label statement in
 342    basic block BB.  */
 343
 344 inline gimple_stmt_iterator
 345 gsi_start_nondebug_after_labels_bb (basic_block bb)
 346 {
 347   gimple_stmt_iterator i = gsi_after_labels (bb);
 348
 349   if (!gsi_end_p (i) && is_gimple_debug (gsi_stmt (i)))
 350     gsi_next_nondebug (&i);
 351
 352   return i;
 353 }
 354
 355 /* Return a new iterator pointing to the last non-debug statement in
 356    basic block BB.  */
 357
 358 inline gimple_stmt_iterator
 359 gsi_last_nondebug_bb (basic_block bb)
 360 {
 361   gimple_stmt_iterator i = gsi_last_bb (bb);
 362
 363   if (!gsi_end_p (i) && is_gimple_debug (gsi_stmt (i)))
 364     gsi_prev_nondebug (&i);
 365
 366   return i;
 367 }
 368
 369 /* Return true if I is followed only by debug statements in its
 370    sequence.  */
 371
 372 inline bool
 373 gsi_one_nondebug_before_end_p (gimple_stmt_iterator i)
 374 {
 375   if (gsi_one_before_end_p (i))
 376     return true;
 377   if (gsi_end_p (i))
 378     return false;
 379   gsi_next_nondebug (&i);
 380   return gsi_end_p (i);
 381 }
 382
 383 /* Advance I statement iterator to the next non-virtual GIMPLE_PHI
 384    statement.  */
 385
 386 inline void
 387 gsi_next_nonvirtual_phi (gphi_iterator *i)
 388 {
 389   do
 390     {
 391       gsi_next (i);
 392     }
 393   while (!gsi_end_p (*i) && virtual_operand_p (gimple_phi_result (i->phi ())));
 394 }
 395
 396 /* Return a new iterator pointing to the first non-virtual phi statement in
 397    basic block BB.  */
 398
 399 inline gphi_iterator
 400 gsi_start_nonvirtual_phis (basic_block bb)
 401 {
 402   gphi_iterator i = gsi_start_phis (bb);
 403
 404   if (!gsi_end_p (i) && virtual_operand_p (gimple_phi_result (i.phi ())))
 405     gsi_next_nonvirtual_phi (&i);
 406
 407   return i;
 408 }
 409
 410 /* Return the basic block associated with this iterator.  */
 411
 412 inline basic_block
 413 gsi_bb (gimple_stmt_iterator i)
 414 {
 415   return i.bb;
 416 }
 417
 418 /* Return the sequence associated with this iterator.  */
 419
 420 inline gimple_seq
 421 gsi_seq (gimple_stmt_iterator i)
 422 {
 423   return *i.seq;
 424 }
 425
 426 /* Determine whether SEQ is a nondebug singleton.  */
 427
 428 inline bool
 429 gimple_seq_nondebug_singleton_p (gimple_seq seq)
 430 {
 431   gimple_stmt_iterator gsi;
 432
 433   /* Find a nondebug gimple.  */
 434   gsi.ptr = gimple_seq_first (seq);
 435   gsi.seq = &seq;
 436   gsi.bb = NULL;
 437   while (!gsi_end_p (gsi)
 438          && is_gimple_debug (gsi_stmt (gsi)))
 439     gsi_next (&gsi);
 440
 441   /* No nondebug gimple found, not a singleton.  */
 442   if (gsi_end_p (gsi))
 443     return false;
 444
 445   /* Find a next nondebug gimple.  */
 446   gsi_next (&gsi);
 447   while (!gsi_end_p (gsi)
 448          && is_gimple_debug (gsi_stmt (gsi)))
 449     gsi_next (&gsi);
 450
 451   /* Only a singleton if there's no next nondebug gimple.  */
 452   return gsi_end_p (gsi);
 453 }
 454
 455 #endif /* GCC_GIMPLE_ITERATOR_H */