Line data    Source code

       1              : /* IPA reference lists.
       2              :    Copyright (C) 2010-2026 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 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 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              :   unsigned int referred_index;
      63              :   /* speculative id is used to link direct calls with their corresponding
      64              :      IPA_REF_ADDR references when representing speculative calls.  */
      65              :   unsigned int speculative_id : 16;
      66              :   ENUM_BITFIELD (ipa_ref_use) use:3;
      67              :   unsigned int speculative:1;
      68              : };
      69              : 
      70              : typedef struct ipa_ref ipa_ref_t;
      71              : 
      72              : 
      73              : /* List of references.  This is stored in both callgraph and varpool nodes.  */
      74              : struct ipa_ref_list
      75              : {
      76              : public:
      77              :   /* Return first reference in list or NULL if empty.  */
      78              :   struct ipa_ref *first_reference (void)
      79              :   {
      80              :     if (!references.length ())
      81              :       return NULL;
      82              :     return &references[0];
      83              :   }
      84              : 
      85              :   /* Return first referring ref in list or NULL if empty.  */
      86          333 :   struct ipa_ref *first_referring (void)
      87              :   {
      88          333 :     if (!referring.length ())
      89              :       return NULL;
      90          114 :     return referring[0];
      91              :   }
      92              : 
      93              :   /* Return first referring alias.  */
      94              :   struct ipa_ref *first_alias (void)
      95              :   {
      96              :     struct ipa_ref *r = first_referring ();
      97              : 
      98              :     return r && r->use == IPA_REF_ALIAS ? r : NULL;
      99              :   }
     100              : 
     101              :   /* Return last referring alias.  */
     102         8639 :   struct ipa_ref *last_alias (void)
     103              :   {
     104         8639 :     unsigned int i = 0;
     105              : 
     106        49925 :     for(i = 0; i < referring.length (); i++)
     107        42747 :       if (referring[i]->use != IPA_REF_ALIAS)
     108              :         break;
     109              : 
     110         8639 :     return i == 0 ? NULL : referring[i - 1];
     111              :   }
     112              : 
     113              :   /* Return true if the symbol has an alias.  */
     114              :   bool inline has_aliases_p (void)
     115              :   {
     116              :     return first_alias ();
     117              :   }
     118              : 
     119              :   /* Clear reference list.  */
     120    156199080 :   void clear (void)
     121              :   {
     122    156199080 :     referring.create (0);
     123    156199080 :     references.create (0);
     124              :   }
     125              : 
     126              :   /* Return number of references.  */
     127       449622 :   unsigned int nreferences (void)
     128              :   {
     129       777118 :     return references.length ();
     130              :   }
     131              : 
     132              :   /* Store actual references in references vector.  */
     133              :   vec<ipa_ref_t, va_heap, vl_ptr> references;
     134              :   /* Referring is vector of pointers to references.  It must not live in GGC space
     135              :      or GGC will try to mark middle of references vectors.  */
     136              :   vec<ipa_ref_t *, va_heap, vl_ptr> referring;
     137              : };
     138              : 
     139              : #endif /* GCC_IPA_REF_H */