LCOV - code coverage report
Current view: top level - gcc - tree-ssa-alias.h (source / functions) Coverage Total Hit
Test: gcc.info Lines: 100.0 % 11 11
Test Date: 2026-11-14 16:39:50 Functions: 100.0 % 1 1
Legend: Lines:     hit not hit

            Line data    Source code
       1              : /* Tree based alias analysis and alias oracle.
       2              :    Copyright (C) 2008-2026 Free Software Foundation, Inc.
       3              :    Contributed by Richard Guenther  <rguenther@suse.de>
       4              : 
       5              :    This file is part of GCC.
       6              : 
       7              :    GCC is free software; you can redistribute it and/or modify
       8              :    under the terms of the GNU General Public License as published by
       9              :    the Free Software Foundation; either version 3 of the License, or
      10              :    (at your option) any later version.
      11              : 
      12              :    GCC is distributed in the hope that it will be useful,
      13              :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      14              :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15              :    GNU General Public License for more details.
      16              : 
      17              :    You should have received a copy of the GNU General Public License
      18              :    along with GCC; see the file COPYING3.  If not see
      19              :    <http://www.gnu.org/licenses/>.  */
      20              : 
      21              : #ifndef TREE_SSA_ALIAS_H
      22              : #define TREE_SSA_ALIAS_H
      23              : 
      24              : /* The points-to solution.
      25              : 
      26              :    The points-to solution is a union of pt_vars and the abstract
      27              :    sets specified by the flags.  */
      28              : struct GTY(()) pt_solution
      29              : {
      30              :   /* Nonzero if points-to analysis couldn't determine where this pointer
      31              :      is pointing to.  */
      32              :   unsigned int anything : 1;
      33              : 
      34              :   /* Nonzero if the points-to set includes any global memory.  Note that
      35              :      even if this is zero pt_vars can still include global variables.  */
      36              :   unsigned int nonlocal : 1;
      37              : 
      38              :   /* Nonzero if the points-to set includes the local escaped solution by
      39              :      reference.  */
      40              :   unsigned int escaped : 1;
      41              : 
      42              :   /* Nonzero if the points-to set includes the IPA escaped solution by
      43              :      reference.  */
      44              :   unsigned int ipa_escaped : 1;
      45              : 
      46              :   /* Nonzero if the points-to set includes a readonly object like a
      47              :      STRING_CST that does not have an underlying declaration but will
      48              :      end up in the constant pool.  */
      49              :   unsigned int const_pool : 1;
      50              : 
      51              :   /* Nonzero if the vars bitmap includes a variable included in 'nonlocal'.  */
      52              :   unsigned int vars_contains_nonlocal : 1;
      53              :   /* Nonzero if the vars bitmap includes a local automatic variable.  */
      54              :   unsigned int vars_contains_auto : 1;
      55              :   /* Nonzero if the vars bitmap includes a variable included in 'escaped'.  */
      56              :   unsigned int vars_contains_escaped : 1;
      57              :   /* Nonzero if the vars bitmap includes a anonymous heap variable that
      58              :      escaped the function and thus became global.  */
      59              :   unsigned int vars_contains_escaped_heap : 1;
      60              :   /* Nonzero if the vars bitmap includes a anonymous variable used to
      61              :      represent storage pointed to by a restrict qualified pointer.  */
      62              :   unsigned int vars_contains_restrict : 1;
      63              :   /* Nonzero if the vars bitmap includes an interposable variable.  */
      64              :   unsigned int vars_contains_interposable : 1;
      65              : 
      66              :   /* Set of variables that this pointer may point to.  */
      67              :   bitmap vars;
      68              : };
      69              : 
      70              : 
      71              : /* Simplified and cached information about a memory reference tree.
      72              :    Used by the alias-oracle internally and externally in alternate
      73              :    interfaces.  */
      74              : class ao_ref
      75              : {
      76              : public:
      77              :   /* The original full memory reference tree or NULL_TREE if that is
      78              :      not available.  */
      79              :   tree ref;
      80              : 
      81              :   /* The following fields are the decomposed reference as returned
      82              :      by get_ref_base_and_extent.  */
      83              :   /* The base object of the memory reference or NULL_TREE if all of
      84              :      the following fields are not yet computed.  */
      85              :   tree base;
      86              :   /* The offset relative to the base.  */
      87              :   poly_int64 offset;
      88              :   /* The size of the access.  */
      89              :   poly_int64 size;
      90              :   /* The maximum possible extent of the access or -1 if unconstrained.  */
      91              :   poly_int64 max_size;
      92              : 
      93              :   /* The alias set of the access or -1 if not yet computed.  */
      94              :   alias_set_type ref_alias_set;
      95              : 
      96              :   /* The alias set of the base object or -1 if not yet computed.  */
      97              :   alias_set_type base_alias_set;
      98              : 
      99              :   /* Whether the memory is considered a volatile access.  */
     100              :   bool volatile_p;
     101              : 
     102              :   bool max_size_known_p () const;
     103              : };
     104              : 
     105              : /* Return true if the maximum size is known, rather than the special -1
     106              :    marker.  */
     107              : 
     108              : inline bool
     109   1126230633 : ao_ref::max_size_known_p () const
     110              : {
     111   1129368754 :   return known_size_p (max_size);
     112              : }
     113              : 
     114              : /* In tree-ssa-alias.cc  */
     115              : extern void ao_ref_init (ao_ref *, tree);
     116              : extern void ao_ref_init_from_ptr_and_size (ao_ref *, tree, tree);
     117              : extern void ao_ref_init_from_ptr_and_range (ao_ref *, tree, bool,
     118              :                                             poly_int64, poly_int64,
     119              :                                             poly_int64);
     120              : extern tree ao_ref_base (ao_ref *);
     121              : extern alias_set_type ao_ref_alias_set (ao_ref *);
     122              : extern alias_set_type ao_ref_base_alias_set (ao_ref *);
     123              : extern tree ao_ref_alias_ptr_type (ao_ref *);
     124              : extern tree ao_ref_base_alias_ptr_type (ao_ref *);
     125              : extern bool ao_ref_alignment (ao_ref *, unsigned int *,
     126              :                               unsigned HOST_WIDE_INT *);
     127              : extern bool ptr_deref_may_alias_global_p (tree, bool);
     128              : extern bool ptr_deref_may_alias_auto_p (tree);
     129              : extern bool ptr_derefs_may_alias_p (tree, tree);
     130              : extern bool ptrs_compare_unequal (tree, tree);
     131              : extern bool ref_may_alias_global_p (tree, bool);
     132              : extern bool ref_may_alias_global_p (ao_ref *, bool);
     133              : extern bool refs_may_alias_p (tree, tree, bool = true);
     134              : extern bool refs_may_alias_p_1 (ao_ref *, ao_ref *, bool);
     135              : extern bool refs_anti_dependent_p (tree, tree);
     136              : extern bool refs_output_dependent_p (tree, tree);
     137              : extern bool ref_maybe_used_by_stmt_p (gimple *, tree, bool = true);
     138              : extern bool ref_maybe_used_by_stmt_p (gimple *, ao_ref *, bool = true);
     139              : extern bool stmt_may_clobber_global_p (gimple *, bool);
     140              : extern bool stmt_may_clobber_ref_p (gimple *, tree, bool = true);
     141              : extern bool stmt_may_clobber_ref_p_1 (gimple *, ao_ref *, bool = true);
     142              : extern bool call_may_clobber_ref_p (gcall *, tree, bool = true);
     143              : extern bool call_may_clobber_ref_p_1 (gcall *, ao_ref *, bool = true);
     144              : extern bool stmt_kills_ref_p (gimple *, tree);
     145              : extern bool stmt_kills_ref_p (gimple *, ao_ref *);
     146              : extern bool ref_can_have_store_data_races (tree);
     147              : 
     148              : enum translate_flags
     149              :   { TR_TRANSLATE, TR_VALUEIZE_AND_DISAMBIGUATE, TR_DISAMBIGUATE };
     150              : extern tree get_continuation_for_phi (gphi *, ao_ref *, bool,
     151              :                                       unsigned int &, bitmap *,
     152              :                                       void *(*)(ao_ref *, tree, void *,
     153              :                                                 translate_flags *),
     154              :                                       void *,
     155              :                                       bool (*)(edge, void *) = nullptr,
     156              :                                       translate_flags
     157              :                                         = TR_VALUEIZE_AND_DISAMBIGUATE);
     158              : extern void *walk_non_aliased_vuses (ao_ref *, tree, bool,
     159              :                                      void *(*)(ao_ref *, tree, void *),
     160              :                                      void *(*)(ao_ref *, tree, void *,
     161              :                                                translate_flags *),
     162              :                                      bool (*)(edge, void *),
     163              :                                      tree (*)(tree), unsigned &, void *);
     164              : extern int walk_aliased_vdefs (ao_ref *, tree,
     165              :                                bool (*)(ao_ref *, tree, void *),
     166              :                                void *, bitmap *,
     167              :                                bool *function_entry_reached = NULL,
     168              :                                unsigned int limit = 0);
     169              : extern void dump_alias_info (FILE *);
     170              : extern void debug_alias_info (void);
     171              : extern void dump_points_to_solution (FILE *, const pt_solution *);
     172              : extern void debug (pt_solution &ref);
     173              : extern void debug (pt_solution *ptr);
     174              : extern void dump_points_to_info_for (FILE *, tree);
     175              : extern void debug_points_to_info_for (tree);
     176              : extern void dump_alias_stats (FILE *);
     177              : 
     178              : 
     179              : /* In tree-ssa-structalias.cc  */
     180              : extern unsigned int compute_may_aliases (void);
     181              : extern bool pt_solution_empty_p (const pt_solution *);
     182              : extern bool pt_solution_singleton_or_null_p (const pt_solution *, unsigned *);
     183              : extern bool pt_solution_includes_global (const pt_solution *, bool);
     184              : extern bool pt_solution_includes_auto (const pt_solution *);
     185              : extern bool pt_solution_includes (const pt_solution *, const_tree);
     186              : extern bool pt_solution_includes_const_pool (const pt_solution *);
     187              : extern bool pt_solutions_intersect (const pt_solution *, const pt_solution *);
     188              : extern void pt_solution_reset (struct pt_solution *);
     189              : extern void pt_solution_set (struct pt_solution *, bitmap, bool);
     190              : extern void pt_solution_set_var (struct pt_solution *, tree);
     191              : 
     192              : extern void dump_pta_stats (FILE *);
     193              : 
     194              : extern GTY(()) struct pt_solution ipa_escaped_pt;
     195              : 
     196              : /* Return true, if the two ranges [POS1, SIZE1] and [POS2, SIZE2]
     197              :    overlap.  SIZE1 and/or SIZE2 can be (unsigned)-1 in which case the
     198              :    range is open-ended.  Otherwise return false.  */
     199              : 
     200              : inline bool
     201      3176201 : ranges_overlap_p (HOST_WIDE_INT pos1,
     202              :                   unsigned HOST_WIDE_INT size1,
     203              :                   HOST_WIDE_INT pos2,
     204              :                   unsigned HOST_WIDE_INT size2)
     205              : {
     206      3176201 :   if (size1 == 0 || size2 == 0)
     207              :     return false;
     208      3176185 :   if (pos1 >= pos2
     209      3174158 :       && (size2 == (unsigned HOST_WIDE_INT)-1
     210      3174158 :           || pos1 < (pos2 + (HOST_WIDE_INT) size2)))
     211              :     return true;
     212      1172879 :   if (pos2 >= pos1
     213         2027 :       && (size1 == (unsigned HOST_WIDE_INT)-1
     214         2027 :           || pos2 < (pos1 + (HOST_WIDE_INT) size1)))
     215         1985 :     return true;
     216              : 
     217              :   return false;
     218              : }
     219              : 
     220              : 
     221              : 
     222              : #endif /* TREE_SSA_ALIAS_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.