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

           Branch data     Line data    Source code
       1                 :            : /* IPA reference lists.
       2                 :            :    Copyright (C) 2010-2020 Free Software Foundation, Inc.
       3                 :            :    Contributed by Jan Hubicka
       4                 :            : 
       5                 :            : This file is part of GCC.
       6                 :            : 
       7                 :            : GCC is free software; you can redistribute it and/or modify it under
       8                 :            : the terms of the GNU General Public License as published by the Free
       9                 :            : Software Foundation; either version 3, or (at your option) any later
      10                 :            : version.
      11                 :            : 
      12                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      13                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      14                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      15                 :            : 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 GCC_IPA_REF_H
      22                 :            : #define GCC_IPA_REF_H
      23                 :            : 
      24                 :            : struct cgraph_node;
      25                 :            : struct varpool_node;
      26                 :            : struct symtab_node;
      27                 :            : 
      28                 :            : 
      29                 :            : /* How the reference is done.  */
      30                 :            : enum GTY(()) ipa_ref_use
      31                 :            : {
      32                 :            :   IPA_REF_LOAD,
      33                 :            :   IPA_REF_STORE,
      34                 :            :   IPA_REF_ADDR,
      35                 :            :   IPA_REF_ALIAS
      36                 :            : };
      37                 :            : 
      38                 :            : /* Record of reference in callgraph or varpool.  */
      39                 :            : struct GTY(()) ipa_ref
      40                 :            : {
      41                 :            : public:
      42                 :            :   /* Remove reference.  */
      43                 :            :   void remove_reference ();
      44                 :            : 
      45                 :            :   /* Return true when execution of reference can lead to return from
      46                 :            :      function.  */
      47                 :            :   bool cannot_lead_to_return ();
      48                 :            : 
      49                 :            :   /* Return true if reference may be used in address compare.  */
      50                 :            :   bool address_matters_p ();
      51                 :            : 
      52                 :            :   /* Return reference list this reference is in.  */
      53                 :            :   struct ipa_ref_list * referring_ref_list (void);
      54                 :            : 
      55                 :            :   /* Return reference list this reference is in.  */
      56                 :            :   struct ipa_ref_list * referred_ref_list (void);
      57                 :            : 
      58                 :            :   symtab_node *referring;
      59                 :            :   symtab_node *referred;
      60                 :            :   gimple *stmt;
      61                 :            :   unsigned int lto_stmt_uid;
      62                 :            :   /* speculative id is used to link direct calls with their corresponding
      63                 :            :      IPA_REF_ADDR references when representing speculative calls.  */
      64                 :            :   unsigned int speculative_id : 16;
      65                 :            :   unsigned int referred_index;
      66                 :            :   ENUM_BITFIELD (ipa_ref_use) use:3;
      67                 :            :   unsigned int speculative:1;
      68                 :            : };
      69                 :            : 
      70                 :            : typedef struct ipa_ref ipa_ref_t;
      71                 :            : typedef struct ipa_ref *ipa_ref_ptr;
      72                 :            : 
      73                 :            : 
      74                 :            : /* List of references.  This is stored in both callgraph and varpool nodes.  */
      75                 :            : struct GTY(()) ipa_ref_list
      76                 :            : {
      77                 :            : public:
      78                 :            :   /* Return first reference in list or NULL if empty.  */
      79                 :            :   struct ipa_ref *first_reference (void)
      80                 :            :   {
      81                 :            :     if (!vec_safe_length (references))
      82                 :            :       return NULL;
      83                 :            :     return &(*references)[0];
      84                 :            :   }
      85                 :            : 
      86                 :            :   /* Return first referring ref in list or NULL if empty.  */
      87                 :        413 :   struct ipa_ref *first_referring (void)
      88                 :            :   {
      89                 :        413 :     if (!referring.length ())
      90                 :            :       return NULL;
      91                 :        150 :     return referring[0];
      92                 :            :   }
      93                 :            : 
      94                 :            :   /* Return first referring alias.  */
      95                 :            :   struct ipa_ref *first_alias (void)
      96                 :            :   {
      97                 :            :     struct ipa_ref *r = first_referring ();
      98                 :            : 
      99                 :            :     return r && r->use == IPA_REF_ALIAS ? r : NULL;
     100                 :            :   }
     101                 :            : 
     102                 :            :   /* Return last referring alias.  */
     103                 :       8080 :   struct ipa_ref *last_alias (void)
     104                 :            :   {
     105                 :       8080 :     unsigned int i = 0;
     106                 :            : 
     107                 :      65318 :     for(i = 0; i < referring.length (); i++)
     108                 :      25790 :       if (referring[i]->use != IPA_REF_ALIAS)
     109                 :            :         break;
     110                 :            : 
     111                 :       8080 :     return i == 0 ? NULL : referring[i - 1];
     112                 :            :   }
     113                 :            : 
     114                 :            :   /* Return true if the symbol has an alias.  */
     115                 :            :   bool inline has_aliases_p (void)
     116                 :            :   {
     117                 :            :     return first_alias ();
     118                 :            :   }
     119                 :            : 
     120                 :            :   /* Clear reference list.  */
     121                 :   48524600 :   void clear (void)
     122                 :            :   {
     123                 :   48524600 :     referring.create (0);
     124                 :   48524600 :     references = NULL;
     125                 :            :   }
     126                 :            : 
     127                 :            :   /* Return number of references.  */
     128                 :     396155 :   unsigned int nreferences (void)
     129                 :            :   {
     130                 :     458799 :     return vec_safe_length (references);
     131                 :            :   }
     132                 :            : 
     133                 :            :   /* Store actual references in references vector.  */
     134                 :            :   vec<ipa_ref_t, va_gc> *references;
     135                 :            :   /* Referring is vector of pointers to references.  It must not live in GGC space
     136                 :            :      or GGC will try to mark middle of references vectors.  */
     137                 :            :   vec<ipa_ref_ptr>  GTY((skip)) referring;
     138                 :            : };
     139                 :            : 
     140                 :            : #endif /* GCC_IPA_REF_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.