LCOV - code coverage report
Current view: top level - gcc - gimple-fold.h (source / functions) Coverage Total Hit
Test: gcc.info Lines: 92.6 % 54 50
Test Date: 2026-11-14 16:39:50 Functions: 73.9 % 23 17
Legend: Lines:     hit not hit

            Line data    Source code
       1              : /* Gimple folding definitions.
       2              : 
       3              :    Copyright (C) 2011-2026 Free Software Foundation, Inc.
       4              :    Contributed by Richard Guenther <rguenther@suse.de>
       5              : 
       6              : This file is part of GCC.
       7              : 
       8              : GCC is free software; you can redistribute it and/or modify it under
       9              : the terms of the GNU General Public License as published by the Free
      10              : Software Foundation; either version 3, or (at your option) any later
      11              : version.
      12              : 
      13              : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      14              : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      15              : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      16              : for more details.
      17              : 
      18              : You should have received a copy of the GNU General Public License
      19              : along with GCC; see the file COPYING3.  If not see
      20              : <http://www.gnu.org/licenses/>.  */
      21              : 
      22              : #ifndef GCC_GIMPLE_FOLD_H
      23              : #define GCC_GIMPLE_FOLD_H
      24              : 
      25              : #include "tree-pass.h"
      26              : 
      27              : extern tree canonicalize_constructor_val (tree, tree);
      28              : extern tree get_symbol_constant_value (tree);
      29              : struct c_strlen_data;
      30              : extern bool get_range_strlen (tree, c_strlen_data *, unsigned eltsize);
      31              : extern void gimplify_and_update_call_from_tree (gimple_stmt_iterator *, tree);
      32              : extern bool update_gimple_call (gimple_stmt_iterator *, tree, int, ...);
      33              : extern tree no_follow_ssa_edges (tree);
      34              : extern tree follow_single_use_edges (tree);
      35              : extern tree follow_all_ssa_edges (tree);
      36              : extern bool fold_stmt (gimple_stmt_iterator *, bitmap = nullptr);
      37              : extern bool fold_stmt (gimple_stmt_iterator *, tree (*) (tree), bitmap = nullptr);
      38              : extern bool fold_stmt_inplace (gimple_stmt_iterator *, tree (*) (tree) = no_follow_ssa_edges);
      39              : extern tree maybe_fold_and_comparisons (tree, enum tree_code,
      40              :                                         enum tree_code, tree, tree,
      41              :                                         enum tree_code, tree, tree,
      42              :                                         basic_block = nullptr);
      43              : extern tree maybe_fold_or_comparisons (tree, enum tree_code,
      44              :                                        enum tree_code, tree, tree,
      45              :                                        enum tree_code, tree, tree,
      46              :                                        basic_block = nullptr);
      47              : extern bool optimize_atomic_compare_exchange_p (gimple *);
      48              : extern void fold_builtin_atomic_compare_exchange (gimple_stmt_iterator *);
      49              : extern tree gimple_fold_stmt_to_constant_1 (gimple *, tree (*) (tree),
      50              :                                             tree (*) (tree) = no_follow_ssa_edges);
      51              : extern tree gimple_fold_stmt_to_constant (gimple *, tree (*) (tree));
      52              : extern tree fold_ctor_reference (tree, tree, const poly_uint64&,
      53              :                                  const poly_uint64&, tree,
      54              :                                  unsigned HOST_WIDE_INT * = NULL);
      55              : extern tree fold_const_aggregate_ref_1 (tree, tree (*) (tree));
      56              : extern tree fold_const_aggregate_ref (tree);
      57              : extern tree gimple_get_virt_method_for_binfo (HOST_WIDE_INT, tree,
      58              :                                               bool *can_refer = NULL);
      59              : extern tree gimple_get_virt_method_for_vtable (HOST_WIDE_INT, tree,
      60              :                                                unsigned HOST_WIDE_INT,
      61              :                                                bool *can_refer = NULL);
      62              : extern tree gimple_fold_indirect_ref (tree);
      63              : extern bool gimple_fold_builtin_sprintf (gimple_stmt_iterator *);
      64              : extern bool gimple_fold_builtin_snprintf (gimple_stmt_iterator *);
      65              : extern bool arith_code_with_undefined_signed_overflow (tree_code);
      66              : extern bool gimple_needing_rewrite_undefined (gimple *, bool = false);
      67              : extern void rewrite_to_defined_unconditional (gimple_stmt_iterator *);
      68              : extern gimple_seq rewrite_to_defined_unconditional (gimple *);
      69              : extern void replace_call_with_value (gimple_stmt_iterator *, tree);
      70              : extern tree tree_vec_extract (gimple_stmt_iterator *, tree, tree, tree, tree);
      71              : extern void gsi_replace_with_seq_vops (gimple_stmt_iterator *, gimple_seq);
      72              : 
      73              : /* gimple_build, functionally matching fold_buildN, outputs stmts
      74              :    int the provided sequence, matching and simplifying them on-the-fly.
      75              :    Supposed to replace force_gimple_operand (fold_buildN (...), ...).  */
      76              : extern tree gimple_build (gimple_stmt_iterator *, bool,
      77              :                           enum gsi_iterator_update,
      78              :                           location_t, enum tree_code, tree, tree);
      79              : extern tree gimple_build (gimple_stmt_iterator *, bool,
      80              :                           enum gsi_iterator_update,
      81              :                           location_t, enum tree_code, tree, tree, tree);
      82              : extern tree gimple_build (gimple_stmt_iterator *, bool,
      83              :                           enum gsi_iterator_update,
      84              :                           location_t, enum tree_code, tree, tree, tree, tree);
      85              : template<class ...Args>
      86              : inline tree
      87       597035 : gimple_build (gimple_seq *seq, location_t loc,
      88              :               enum tree_code code, tree type, Args ...ops)
      89              : {
      90              :   static_assert (sizeof...(ops) > 0 && sizeof...(ops) <= 3,
      91              :                  "Number of operands must be from one to three");
      92       597035 :   gimple_stmt_iterator gsi = gsi_last (*seq);
      93       597035 :   return gimple_build (&gsi, false, GSI_CONTINUE_LINKING,
      94       597035 :                        loc, code, type, ops...);
      95              : }
      96              : template<class ...Args>
      97              : inline tree
      98       364643 : gimple_build (gimple_seq *seq, enum tree_code code, tree type, Args ...ops)
      99              : {
     100              :   static_assert (sizeof...(ops) > 0 && sizeof...(ops) <= 3,
     101              :                  "Number of operands must be from one to three");
     102       364643 :   gimple_stmt_iterator gsi = gsi_last (*seq);
     103       364643 :   return gimple_build (&gsi, false, GSI_CONTINUE_LINKING,
     104       364643 :                        UNKNOWN_LOCATION, code, type, ops...);
     105              : }
     106              : 
     107              : extern tree gimple_build (gimple_stmt_iterator *, bool,
     108              :                           enum gsi_iterator_update,
     109              :                           location_t, combined_fn, tree);
     110              : extern tree gimple_build (gimple_stmt_iterator *, bool,
     111              :                           enum gsi_iterator_update,
     112              :                           location_t, combined_fn, tree, tree);
     113              : extern tree gimple_build (gimple_stmt_iterator *, bool,
     114              :                           enum gsi_iterator_update,
     115              :                           location_t, combined_fn, tree, tree, tree);
     116              : extern tree gimple_build (gimple_stmt_iterator *, bool,
     117              :                           enum gsi_iterator_update,
     118              :                           location_t, combined_fn, tree, tree, tree, tree);
     119              : template<class ...Args>
     120              : inline tree
     121          372 : gimple_build (gimple_seq *seq, location_t loc,
     122              :               combined_fn fn, tree type, Args ...args)
     123              : {
     124              :   static_assert (sizeof...(args) < 4,
     125              :                  "Number of arguments must be less than four");
     126          372 :   gimple_stmt_iterator gsi = gsi_last (*seq);
     127          372 :   return gimple_build (&gsi, false, GSI_CONTINUE_LINKING,
     128          372 :                        loc, fn, type, args...);
     129              : }
     130              : template<class ...Args>
     131              : inline tree
     132        21419 : gimple_build (gimple_seq *seq, combined_fn fn, tree type, Args ...args)
     133              : {
     134              :   static_assert (sizeof...(args) < 4,
     135              :                  "Number of arguments must be less than four");
     136        21419 :   gimple_stmt_iterator gsi = gsi_last (*seq);
     137        21419 :   return gimple_build (&gsi, false, GSI_CONTINUE_LINKING,
     138        21419 :                        UNKNOWN_LOCATION, fn, type, args...);
     139              : }
     140              : 
     141              : extern tree gimple_build (gimple_stmt_iterator *, bool,
     142              :                           enum gsi_iterator_update,
     143              :                           location_t, code_helper, tree, tree);
     144              : extern tree gimple_build (gimple_stmt_iterator *, bool,
     145              :                           enum gsi_iterator_update,
     146              :                           location_t, code_helper, tree, tree, tree);
     147              : extern tree gimple_build (gimple_stmt_iterator *, bool,
     148              :                           enum gsi_iterator_update,
     149              :                           location_t, code_helper, tree, tree, tree, tree);
     150              : 
     151              : template<class ...Args>
     152              : inline tree
     153          159 : gimple_build (gimple_seq *seq, location_t loc,
     154              :               code_helper code, tree type, Args ...ops)
     155              : {
     156              :   static_assert (sizeof...(ops) < 4,
     157              :                  "Number of operands must be less than four");
     158          159 :   gimple_stmt_iterator gsi = gsi_last (*seq);
     159          159 :   return gimple_build (&gsi, false, GSI_CONTINUE_LINKING,
     160          159 :                        loc, code, type, ops...);
     161              : }
     162              : template<class ...Args>
     163              : inline tree
     164        23657 : gimple_build (gimple_seq *seq,
     165              :               code_helper code, tree type, Args ...ops)
     166              : {
     167              :   static_assert (sizeof...(ops) < 4,
     168              :                  "Number of operands must be less than four");
     169        23657 :   gimple_stmt_iterator gsi = gsi_last (*seq);
     170        23657 :   return gimple_build (&gsi, false, GSI_CONTINUE_LINKING,
     171        23657 :                        UNKNOWN_LOCATION, code, type, ops...);
     172              : }
     173              : 
     174              : extern tree gimple_convert (gimple_stmt_iterator *, bool,
     175              :                             enum gsi_iterator_update,
     176              :                             location_t, tree, tree);
     177              : inline tree
     178        21700 : gimple_convert (gimple_seq *seq, location_t loc, tree type, tree op)
     179              : {
     180        21700 :   gimple_stmt_iterator gsi = gsi_last (*seq);
     181        21700 :   return gimple_convert (&gsi, false, GSI_CONTINUE_LINKING, loc, type, op);
     182              : }
     183              : inline tree
     184      1936720 : gimple_convert (gimple_seq *seq, tree type, tree op)
     185              : {
     186      1936720 :   gimple_stmt_iterator gsi = gsi_last (*seq);
     187      1936720 :   return gimple_convert (&gsi, false, GSI_CONTINUE_LINKING,
     188      1936720 :                          UNKNOWN_LOCATION, type, op);
     189              : }
     190              : 
     191              : extern tree gimple_convert_to_ptrofftype (gimple_stmt_iterator *, bool,
     192              :                                           enum gsi_iterator_update,
     193              :                                           location_t, tree);
     194              : inline tree
     195          206 : gimple_convert_to_ptrofftype (gimple_seq *seq, location_t loc, tree op)
     196              : {
     197          206 :   gimple_stmt_iterator gsi = gsi_last (*seq);
     198          206 :   return gimple_convert_to_ptrofftype (&gsi, false, GSI_CONTINUE_LINKING,
     199          206 :                                        loc, op);
     200              : }
     201              : inline tree
     202              : gimple_convert_to_ptrofftype (gimple_seq *seq, tree op)
     203              : {
     204              :   gimple_stmt_iterator gsi = gsi_last (*seq);
     205              :   return gimple_convert_to_ptrofftype (&gsi, false, GSI_CONTINUE_LINKING,
     206              :                                        UNKNOWN_LOCATION, op);
     207              : }
     208              : 
     209              : extern tree gimple_build_vector_from_val (gimple_stmt_iterator *, bool,
     210              :                                           enum gsi_iterator_update,
     211              :                                           location_t, tree, tree);
     212              : inline tree
     213           91 : gimple_build_vector_from_val (gimple_seq *seq, location_t loc,
     214              :                               tree type, tree op)
     215              : {
     216           91 :   gimple_stmt_iterator gsi = gsi_last (*seq);
     217           91 :   return gimple_build_vector_from_val (&gsi, false, GSI_CONTINUE_LINKING,
     218           91 :                                        loc, type, op);
     219              : }
     220              : inline tree
     221       329495 : gimple_build_vector_from_val (gimple_seq *seq, tree type, tree op)
     222              : {
     223       329495 :   gimple_stmt_iterator gsi = gsi_last (*seq);
     224       329495 :   return gimple_build_vector_from_val (&gsi, false, GSI_CONTINUE_LINKING,
     225       329495 :                                        UNKNOWN_LOCATION, type, op);
     226              : }
     227              : 
     228              : class tree_vector_builder;
     229              : extern tree gimple_build_vector (gimple_stmt_iterator *, bool,
     230              :                                  enum gsi_iterator_update,
     231              :                                  location_t, tree_vector_builder *);
     232              : inline tree
     233              : gimple_build_vector (gimple_seq *seq, location_t loc,
     234              :                      tree_vector_builder *builder)
     235              : {
     236              :   gimple_stmt_iterator gsi = gsi_last (*seq);
     237              :   return gimple_build_vector (&gsi, false, GSI_CONTINUE_LINKING,
     238              :                               loc, builder);
     239              : }
     240              : inline tree
     241       379555 : gimple_build_vector (gimple_seq *seq, tree_vector_builder *builder)
     242              : {
     243       379555 :   gimple_stmt_iterator gsi = gsi_last (*seq);
     244       379555 :   return gimple_build_vector (&gsi, false, GSI_CONTINUE_LINKING,
     245       379555 :                               UNKNOWN_LOCATION, builder);
     246              : }
     247              : 
     248              : extern tree gimple_build_round_up (gimple_stmt_iterator *, bool,
     249              :                                    enum gsi_iterator_update,
     250              :                                    location_t, tree, tree,
     251              :                                    unsigned HOST_WIDE_INT);
     252              : inline tree
     253            0 : gimple_build_round_up (gimple_seq *seq, location_t loc,
     254              :                        tree type, tree old_size, unsigned HOST_WIDE_INT align)
     255              : {
     256            0 :   gimple_stmt_iterator gsi = gsi_last (*seq);
     257            0 :   return gimple_build_round_up (&gsi, false, GSI_CONTINUE_LINKING,
     258            0 :                                 loc, type, old_size, align);
     259              : }
     260              : inline tree
     261              : gimple_build_round_up (gimple_seq *seq, tree type, tree old_size,
     262              :                        unsigned HOST_WIDE_INT align)
     263              : {
     264              :   gimple_stmt_iterator gsi = gsi_last (*seq);
     265              :   return gimple_build_round_up (&gsi, false, GSI_CONTINUE_LINKING,
     266              :                                 UNKNOWN_LOCATION, type, old_size, align);
     267              : }
     268              : 
     269              : extern bool gimple_stmt_nonnegative_p (gimple *, int = 0);
     270              : extern bool gimple_stmt_integer_valued_real_p (gimple *, int = 0);
     271              : extern void mark_lhs_in_seq_for_dce (bitmap, gimple_seq);
     272              : 
     273              : /* In gimple-match-exports.cc.  */
     274              : extern tree gimple_simplify (enum tree_code, tree, tree,
     275              :                              gimple_seq *, tree (*)(tree));
     276              : extern tree gimple_simplify (enum tree_code, tree, tree, tree,
     277              :                              gimple_seq *, tree (*)(tree));
     278              : extern tree gimple_simplify (enum tree_code, tree, tree, tree, tree,
     279              :                              gimple_seq *, tree (*)(tree));
     280              : extern tree gimple_simplify (combined_fn, tree, tree,
     281              :                              gimple_seq *, tree (*)(tree));
     282              : extern tree gimple_simplify (combined_fn, tree, tree, tree,
     283              :                              gimple_seq *, tree (*)(tree));
     284              : extern tree gimple_simplify (combined_fn, tree, tree, tree, tree,
     285              :                              gimple_seq *, tree (*)(tree));
     286              : 
     287              : /* Returns true if we are doing the fold before expansion to rtl.   */
     288              : inline bool
     289      6452761 : fold_before_rtl_expansion_p ()
     290              : {
     291      6452627 :   if (!cfun)
     292              :     return false;
     293      6451615 :   return (cfun->curr_properties & PROP_last_full_fold) != 0;
     294              : }
     295              : 
     296              : #endif  /* GCC_GIMPLE_FOLD_H */
        

Generated by: LCOV version 2.5.0-beta

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,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.