LCOV - code coverage report
Current view: top level - gcc - gimple-iterator.h (source / functions) Hit Total Coverage
Test: gcc.info Lines: 104 108 96.3 %
Date: 2020-03-28 11:57:23 Functions: 5 5 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Header file for gimple iterators.
       2                 :            :    Copyright (C) 2013-2020 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                 : 1227033569 :   gphi *phi () const
      42                 :            :   {
      43                 : 2846743441 :     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 gimple_stmt_iterator gsi_for_stmt (gimple *, gimple_seq *);
      83                 :            : extern gphi_iterator gsi_for_phi (gphi *);
      84                 :            : extern void gsi_move_after (gimple_stmt_iterator *, gimple_stmt_iterator *);
      85                 :            : extern void gsi_move_before (gimple_stmt_iterator *, gimple_stmt_iterator *);
      86                 :            : extern void gsi_move_to_bb_end (gimple_stmt_iterator *, basic_block);
      87                 :            : extern void gsi_insert_on_edge (edge, gimple *);
      88                 :            : extern void gsi_insert_seq_on_edge (edge, gimple_seq);
      89                 :            : extern basic_block gsi_insert_on_edge_immediate (edge, gimple *);
      90                 :            : extern basic_block gsi_insert_seq_on_edge_immediate (edge, gimple_seq);
      91                 :            : extern void gsi_commit_edge_inserts (void);
      92                 :            : extern void gsi_commit_one_edge_insert (edge, basic_block *);
      93                 :            : extern gphi_iterator gsi_start_phis (basic_block);
      94                 :            : extern void update_modified_stmts (gimple_seq);
      95                 :            : 
      96                 :            : /* Return a new iterator pointing to GIMPLE_SEQ's first statement.  */
      97                 :            : 
      98                 :            : static inline gimple_stmt_iterator
      99                 :  220361885 : gsi_start_1 (gimple_seq *seq)
     100                 :            : {
     101                 :  220361885 :   gimple_stmt_iterator i;
     102                 :            : 
     103                 :  232831220 :   i.ptr = gimple_seq_first (*seq);
     104                 :  220480422 :   i.seq = seq;
     105                 :  120377305 :   i.bb = i.ptr ? gimple_bb (i.ptr) : NULL;
     106                 :            : 
     107                 :  220284485 :   return i;
     108                 :            : }
     109                 :            : 
     110                 :            : #define gsi_start(x) gsi_start_1 (&(x))
     111                 :            : 
     112                 :            : static inline gimple_stmt_iterator
     113                 :    1843745 : gsi_none (void)
     114                 :            : {
     115                 :    1843745 :   gimple_stmt_iterator i;
     116                 :    1843745 :   i.ptr = NULL;
     117                 :    1843745 :   i.seq = NULL;
     118                 :    1843745 :   i.bb = NULL;
     119                 :    1843745 :   return i;
     120                 :            : }
     121                 :            : 
     122                 :            : /* Return a new iterator pointing to the first statement in basic block BB.  */
     123                 :            : 
     124                 :            : static inline gimple_stmt_iterator
     125                 : 7514034143 : gsi_start_bb (basic_block bb)
     126                 :            : {
     127                 : 7523794435 :   gimple_stmt_iterator i;
     128                 : 5131199025 :   gimple_seq *seq;
     129                 :            : 
     130                 : 7331291112 :   seq = bb_seq_addr (bb);
     131                 : 7521387231 :   i.ptr = gimple_seq_first (*seq);
     132                 : 7521388435 :   i.seq = seq;
     133                 : 7521388435 :   i.bb = bb;
     134                 :            : 
     135                 : 7396869811 :   return i;
     136                 :            : }
     137                 :            : 
     138                 :            : gimple_stmt_iterator gsi_start_edge (edge e);
     139                 :            : 
     140                 :            : /* Return a new iterator initially pointing to GIMPLE_SEQ's last statement.  */
     141                 :            : 
     142                 :            : static inline gimple_stmt_iterator
     143                 :  790333807 : gsi_last_1 (gimple_seq *seq)
     144                 :            : {
     145                 :  790333807 :   gimple_stmt_iterator i;
     146                 :            : 
     147                 :  790333807 :   i.ptr = gimple_seq_last (*seq);
     148                 :  790333807 :   i.seq = seq;
     149                 :  788151708 :   i.bb = i.ptr ? gimple_bb (i.ptr) : NULL;
     150                 :            : 
     151                 :  790333807 :   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                 :            : 
     158                 :            : static inline gimple_stmt_iterator
     159                 : 2716698728 : gsi_last_bb (basic_block bb)
     160                 :            : {
     161                 : 2716698728 :   gimple_stmt_iterator i;
     162                 : 2716698728 :   gimple_seq *seq;
     163                 :            : 
     164                 : 1387628339 :   seq = bb_seq_addr (bb);
     165                 : 2716713628 :   i.ptr = gimple_seq_last (*seq);
     166                 : 2716696143 :   i.seq = seq;
     167                 : 2713210824 :   i.bb = bb;
     168                 :            : 
     169                 : 1368647754 :   return i;
     170                 :            : }
     171                 :            : 
     172                 :            : /* Return true if I is at the end of its sequence.  */
     173                 :            : 
     174                 :            : static inline bool
     175                 :72688548952 : gsi_end_p (gimple_stmt_iterator i)
     176                 :            : {
     177                 :70336411457 :   return i.ptr == NULL;
     178                 :            : }
     179                 :            : 
     180                 :            : /* Return true if I is one statement before the end of its sequence.  */
     181                 :            : 
     182                 :            : static inline bool
     183                 :  388266265 : gsi_one_before_end_p (gimple_stmt_iterator i)
     184                 :            : {
     185                 :  387966975 :   return i.ptr != NULL && i.ptr->next == NULL;
     186                 :            : }
     187                 :            : 
     188                 :            : /* Advance the iterator to the next gimple statement.  */
     189                 :            : 
     190                 :            : static inline void
     191                 :50982978705 : gsi_next (gimple_stmt_iterator *i)
     192                 :            : {
     193                 :16091987137 :   i->ptr = i->ptr->next;
     194                 :49778092343 : }
     195                 :            : 
     196                 :            : /* Advance the iterator to the previous gimple statement.  */
     197                 :            : 
     198                 :            : static inline void
     199                 : 1740434417 : gsi_prev (gimple_stmt_iterator *i)
     200                 :            : {
     201                 : 1740434417 :   gimple *prev = i->ptr->prev;
     202                 : 1457101239 :   if (prev->next)
     203                 :  675133529 :     i->ptr = prev;
     204                 :            :   else
     205                 :  178146094 :     i->ptr = NULL;
     206                 :            : }
     207                 :            : 
     208                 :            : /* Return the current stmt.  */
     209                 :            : 
     210                 :            : static inline gimple *
     211                 :60817464774 : gsi_stmt (gimple_stmt_iterator i)
     212                 :            : {
     213                 :58092894918 :   return i.ptr;
     214                 :            : }
     215                 :            : 
     216                 :            : /* Return a block statement iterator that points to the first
     217                 :            :    non-label statement in block BB.  */
     218                 :            : 
     219                 :            : static inline gimple_stmt_iterator
     220                 :   87324962 : gsi_after_labels (basic_block bb)
     221                 :            : {
     222                 :   84570726 :   gimple_stmt_iterator gsi = gsi_start_bb (bb);
     223                 :            : 
     224                 :   93234656 :   for (; !gsi_end_p (gsi); )
     225                 :            :     {
     226                 :   74814293 :       if (gimple_code (gsi_stmt (gsi)) == GIMPLE_LABEL)
     227                 :    5909730 :         gsi_next (&gsi);
     228                 :            :       else
     229                 :            :         break;
     230                 :            :     }
     231                 :            : 
     232                 :   74599853 :   return gsi;
     233                 :            : }
     234                 :            : 
     235                 :            : /* Advance the iterator to the next non-debug gimple statement.  */
     236                 :            : 
     237                 :            : static inline void
     238                 :  180974356 : gsi_next_nondebug (gimple_stmt_iterator *i)
     239                 :            : {
     240                 :  450528282 :   do
     241                 :            :     {
     242                 :  450528282 :       gsi_next (i);
     243                 :            :     }
     244                 :  449883573 :   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                 :            : 
     249                 :            : static inline void
     250                 :     181384 : gsi_prev_nondebug (gimple_stmt_iterator *i)
     251                 :            : {
     252                 :  285701172 :   do
     253                 :            :     {
     254                 :  179509991 :       gsi_prev (i);
     255                 :            :     }
     256                 :  285701172 :   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                 :            : 
     262                 :            : static inline gimple_stmt_iterator
     263                 :            : gsi_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                 :            : 
     275                 :            : static inline gimple_stmt_iterator
     276                 :  124517580 : gsi_start_nondebug_bb (basic_block bb)
     277                 :            : {
     278                 :  124517580 :   gimple_stmt_iterator i = gsi_start_bb (bb);
     279                 :            : 
     280                 :  124517580 :   if (!gsi_end_p (i) && is_gimple_debug (gsi_stmt (i)))
     281                 :  157423850 :     gsi_next_nondebug (&i);
     282                 :            : 
     283                 :  124517580 :   return i;
     284                 :            : }
     285                 :            : 
     286                 :            : /* Return a new iterator pointing to the first non-debug non-label statement in
     287                 :            :    basic block BB.  */
     288                 :            : 
     289                 :            : static inline gimple_stmt_iterator
     290                 :    2904157 : gsi_start_nondebug_after_labels_bb (basic_block bb)
     291                 :            : {
     292                 :    2904157 :   gimple_stmt_iterator i = gsi_after_labels (bb);
     293                 :            : 
     294                 :    2904157 :   if (!gsi_end_p (i) && is_gimple_debug (gsi_stmt (i)))
     295                 :    3703703 :     gsi_next_nondebug (&i);
     296                 :            : 
     297                 :    2904157 :   return i;
     298                 :            : }
     299                 :            : 
     300                 :            : /* Return a new iterator pointing to the last non-debug statement in
     301                 :            :    basic block BB.  */
     302                 :            : 
     303                 :            : static inline gimple_stmt_iterator
     304                 : 1362867562 : gsi_last_nondebug_bb (basic_block bb)
     305                 :            : {
     306                 : 1362867562 :   gimple_stmt_iterator i = gsi_last_bb (bb);
     307                 :            : 
     308                 : 1362867562 :   if (!gsi_end_p (i) && is_gimple_debug (gsi_stmt (i)))
     309                 :  240076827 :     gsi_prev_nondebug (&i);
     310                 :            : 
     311                 : 1362867562 :   return i;
     312                 :            : }
     313                 :            : 
     314                 :            : /* Return true if I is followed only by debug statements in its
     315                 :            :    sequence.  */
     316                 :            : 
     317                 :            : static inline bool
     318                 :     298926 : gsi_one_nondebug_before_end_p (gimple_stmt_iterator i)
     319                 :            : {
     320                 :     298926 :   if (gsi_one_before_end_p (i))
     321                 :            :     return true;
     322                 :            :   if (gsi_end_p (i))
     323                 :            :     return false;
     324                 :          0 :   gsi_next_nondebug (&i);
     325                 :          0 :   return gsi_end_p (i);
     326                 :            : }
     327                 :            : 
     328                 :            : /* Advance I statement iterator to the next non-virtual GIMPLE_PHI
     329                 :            :    statement.  */
     330                 :            : 
     331                 :            : static inline void
     332                 :     109912 : gsi_next_nonvirtual_phi (gphi_iterator *i)
     333                 :            : {
     334                 :     119468 :   do
     335                 :            :     {
     336                 :     119468 :       gsi_next (i);
     337                 :            :     }
     338                 :     134480 :   while (!gsi_end_p (*i) && virtual_operand_p (gimple_phi_result (i->phi ())));
     339                 :     109912 : }
     340                 :            : 
     341                 :            : /* Return a new iterator pointing to the first non-virtual phi statement in
     342                 :            :    basic block BB.  */
     343                 :            : 
     344                 :            : static inline gphi_iterator
     345                 :     615152 : gsi_start_nonvirtual_phis (basic_block bb)
     346                 :            : {
     347                 :     615152 :   gphi_iterator i = gsi_start_phis (bb);
     348                 :            : 
     349                 :     722814 :   if (!gsi_end_p (i) && virtual_operand_p (gimple_phi_result (i.phi ())))
     350                 :      86136 :     gsi_next_nonvirtual_phi (&i);
     351                 :            : 
     352                 :     615152 :   return i;
     353                 :            : }
     354                 :            : 
     355                 :            : /* Return the basic block associated with this iterator.  */
     356                 :            : 
     357                 :            : static inline basic_block
     358                 :  265644040 : gsi_bb (gimple_stmt_iterator i)
     359                 :            : {
     360                 :  265642482 :   return i.bb;
     361                 :            : }
     362                 :            : 
     363                 :            : /* Return the sequence associated with this iterator.  */
     364                 :            : 
     365                 :            : static inline gimple_seq
     366                 :     525590 : gsi_seq (gimple_stmt_iterator i)
     367                 :            : {
     368                 :     525590 :   return *i.seq;
     369                 :            : }
     370                 :            : 
     371                 :            : /* Determine whether SEQ is a nondebug singleton.  */
     372                 :            : 
     373                 :            : static inline bool
     374                 :            : gimple_seq_nondebug_singleton_p (gimple_seq seq)
     375                 :            : {
     376                 :            :   gimple_stmt_iterator gsi;
     377                 :            : 
     378                 :            :   /* Find a nondebug gimple.  */
     379                 :        669 :   gsi.ptr = gimple_seq_first (seq);
     380                 :        669 :   gsi.seq = &seq;
     381                 :        669 :   gsi.bb = NULL;
     382                 :        669 :   while (!gsi_end_p (gsi)
     383                 :        669 :          && is_gimple_debug (gsi_stmt (gsi)))
     384                 :          0 :     gsi_next (&gsi);
     385                 :            : 
     386                 :            :   /* No nondebug gimple found, not a singleton.  */
     387                 :        669 :   if (gsi_end_p (gsi))
     388                 :            :     return false;
     389                 :            : 
     390                 :            :   /* Find a next nondebug gimple.  */
     391                 :        669 :   gsi_next (&gsi);
     392                 :        669 :   while (!gsi_end_p (gsi)
     393                 :        669 :          && is_gimple_debug (gsi_stmt (gsi)))
     394                 :          0 :     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 */

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.