LCOV - code coverage report
Current view: top level - gcc - gimple-ssa.h (source / functions) Hit Total Coverage
Test: gcc.info Lines: 32 34 94.1 %
Date: 2020-04-04 11:58:09 Functions: 2 2 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 routines that straddle the border between GIMPLE and
       2                 :            :    SSA in gimple.
       3                 :            :    Copyright (C) 2009-2020 Free Software Foundation, Inc.
       4                 :            : 
       5                 :            : This file is part of GCC.
       6                 :            : 
       7                 :            : GCC is free software; you can redistribute it and/or modify
       8                 :            : it under the terms of the GNU General Public License as published by
       9                 :            : the Free Software Foundation; either version 3, or (at your option)
      10                 :            : 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 GCC_GIMPLE_SSA_H
      22                 :            : #define GCC_GIMPLE_SSA_H
      23                 :            : 
      24                 :            : #include "tree-ssa-operands.h"
      25                 :            : 
      26                 :            : /* This structure is used to map a gimple statement to a label,
      27                 :            :    or list of labels to represent transaction restart.  */
      28                 :            : 
      29                 :            : struct GTY((for_user)) tm_restart_node {
      30                 :            :   gimple *stmt;
      31                 :            :   tree label_or_list;
      32                 :            : };
      33                 :            : 
      34                 :            : /* Hasher for tm_restart_node.  */
      35                 :            : 
      36                 :            : struct tm_restart_hasher : ggc_ptr_hash<tm_restart_node>
      37                 :            : {
      38                 :       4377 :   static hashval_t hash (tm_restart_node *n) { return htab_hash_pointer (n); }
      39                 :            : 
      40                 :            :   static bool
      41                 :          0 :   equal (tm_restart_node *a, tm_restart_node *b)
      42                 :            :   {
      43                 :          0 :     return a == b;
      44                 :            :   }
      45                 :            : };
      46                 :            : 
      47                 :            : extern void gt_ggc_mx (gimple *&);
      48                 :            : extern void gt_pch_nx (gimple *&);
      49                 :            : 
      50                 :            : struct ssa_name_hasher : ggc_ptr_hash<tree_node>
      51                 :            : {
      52                 :            :   /* Hash a tree in a uid_decl_map.  */
      53                 :            : 
      54                 :            :   static hashval_t
      55                 :   17752000 :   hash (tree item)
      56                 :            :   {
      57                 :   17752000 :     return item->ssa_name.var->decl_minimal.uid;
      58                 :            :   }
      59                 :            : 
      60                 :            :   /* Return true if the DECL_UID in both trees are equal.  */
      61                 :            : 
      62                 :            :   static bool
      63                 :  299798000 :   equal (tree a, tree b)
      64                 :            : {
      65                 :  299798000 :   return (a->ssa_name.var->decl_minimal.uid == b->ssa_name.var->decl_minimal.uid);
      66                 :            : }
      67                 :            : };
      68                 :            : 
      69                 :            : /* Gimple dataflow datastructure. All publicly available fields shall have
      70                 :            :    gimple_ accessor defined, all publicly modifiable fields should have
      71                 :            :    gimple_set accessor.  */
      72                 :            : struct GTY(()) gimple_df {
      73                 :            :   /* Array of all SSA_NAMEs used in the function.  */
      74                 :            :   vec<tree, va_gc> *ssa_names;
      75                 :            : 
      76                 :            :   /* Artificial variable used for the virtual operand FUD chain.  */
      77                 :            :   tree vop;
      78                 :            : 
      79                 :            :   /* The PTA solution for the ESCAPED artificial variable.  */
      80                 :            :   struct pt_solution escaped;
      81                 :            : 
      82                 :            :   /* A map of decls to artificial ssa-names that point to the partition
      83                 :            :      of the decl.  */
      84                 :            :   hash_map<tree, tree> * GTY((skip(""))) decls_to_pointers;
      85                 :            : 
      86                 :            :   /* Free list of SSA_NAMEs.  */
      87                 :            :   vec<tree, va_gc> *free_ssanames;
      88                 :            : 
      89                 :            :   /* Queue of SSA_NAMEs to be freed at the next opportunity.  */
      90                 :            :   vec<tree, va_gc> *free_ssanames_queue;
      91                 :            : 
      92                 :            :   /* Hashtable holding definition for symbol.  If this field is not NULL, it
      93                 :            :      means that the first reference to this variable in the function is a
      94                 :            :      USE or a VUSE.  In those cases, the SSA renamer creates an SSA name
      95                 :            :      for this variable with an empty defining statement.  */
      96                 :            :   hash_table<ssa_name_hasher> *default_defs;
      97                 :            : 
      98                 :            :   /* True if there are any symbols that need to be renamed.  */
      99                 :            :   unsigned int ssa_renaming_needed : 1;
     100                 :            : 
     101                 :            :   /* True if all virtual operands need to be renamed.  */
     102                 :            :   unsigned int rename_vops : 1;
     103                 :            : 
     104                 :            :   /* True if the code is in ssa form.  */
     105                 :            :   unsigned int in_ssa_p : 1;
     106                 :            : 
     107                 :            :   /* True if IPA points-to information was computed for this function.  */
     108                 :            :   unsigned int ipa_pta : 1;
     109                 :            : 
     110                 :            :   struct ssa_operands ssa_operands;
     111                 :            : 
     112                 :            :   /* Map gimple stmt to tree label (or list of labels) for transaction
     113                 :            :      restart and abort.  */
     114                 :            :   hash_table<tm_restart_hasher> *tm_restart;
     115                 :            : };
     116                 :            : 
     117                 :            : 
     118                 :            : /* Return true when gimple SSA form was built.
     119                 :            :    gimple_in_ssa_p is queried by gimplifier in various early stages before SSA
     120                 :            :    infrastructure is initialized.  Check for presence of the datastructures
     121                 :            :    at first place.  */
     122                 :            : static inline bool
     123                 :  124038194 : gimple_in_ssa_p (const struct function *fun)
     124                 :            : {
     125                 :  123237694 :   return fun && fun->gimple_df && fun->gimple_df->in_ssa_p;
     126                 :            : }
     127                 :            : 
     128                 :            : /* Artificial variable used for the virtual operand FUD chain.  */
     129                 :            : static inline tree
     130                 : 6479886047 : gimple_vop (const struct function *fun)
     131                 :            : {
     132                 : 6356906047 :   gcc_checking_assert (fun && fun->gimple_df);
     133                 : 6356906047 :   return fun->gimple_df->vop;
     134                 :            : }
     135                 :            : 
     136                 :            : /* Return the set of VUSE operand for statement G.  */
     137                 :            : 
     138                 :            : static inline use_operand_p
     139                 : 1853179725 : gimple_vuse_op (const gimple *g)
     140                 :            : {
     141                 : 1853179725 :   struct use_optype_d *ops;
     142                 : 1853179725 :   const gimple_statement_with_memory_ops *mem_ops_stmt =
     143                 : 2115419147 :      dyn_cast <const gimple_statement_with_memory_ops *> (g);
     144                 : 1853179725 :   if (!mem_ops_stmt)
     145                 :            :     return NULL_USE_OPERAND_P;
     146                 : 1853179725 :   ops = mem_ops_stmt->use_ops;
     147                 : 1853179725 :   if (ops
     148                 : 1853179725 :       && USE_OP_PTR (ops)->use == &mem_ops_stmt->vuse)
     149                 : 1853179725 :     return USE_OP_PTR (ops);
     150                 :            :   return NULL_USE_OPERAND_P;
     151                 :            : }
     152                 :            : 
     153                 :            : /* Return the set of VDEF operand for statement G.  */
     154                 :            : 
     155                 :            : static inline def_operand_p
     156                 :            : gimple_vdef_op (gimple *g)
     157                 :            : {
     158                 :            :   gimple_statement_with_memory_ops *mem_ops_stmt =
     159                 :            :      dyn_cast <gimple_statement_with_memory_ops *> (g);
     160                 :            :   if (!mem_ops_stmt)
     161                 :            :     return NULL_DEF_OPERAND_P;
     162                 :            :   if (mem_ops_stmt->vdef)
     163                 :            :     return &mem_ops_stmt->vdef;
     164                 :            :   return NULL_DEF_OPERAND_P;
     165                 :            : }
     166                 :            : 
     167                 :            : /* Mark statement S as modified, and update it.  */
     168                 :            : 
     169                 :            : static inline void
     170                 :  131302204 : update_stmt (gimple *s)
     171                 :            : {
     172                 :  752100936 :   if (gimple_has_ops (s))
     173                 :            :     {
     174                 :  130313732 :       gimple_set_modified (s, true);
     175                 :  130313732 :       update_stmt_operands (cfun, s);
     176                 :            :     }
     177                 :      11162 : }
     178                 :            : 
     179                 :            : /* Update statement S if it has been optimized.  */
     180                 :            : 
     181                 :            : static inline void
     182                 :  945274000 : update_stmt_if_modified (gimple *s)
     183                 :            : {
     184                 : 1877226000 :   if (gimple_modified_p (s))
     185                 :  102364720 :     update_stmt_operands (cfun, s);
     186                 :  945274000 : }
     187                 :            : 
     188                 :            : /* Mark statement S as modified, and update it.  */
     189                 :            : 
     190                 :            : static inline void
     191                 :     241481 : update_stmt_fn (struct function *fn, gimple *s)
     192                 :            : {
     193                 :    1020066 :   if (gimple_has_ops (s))
     194                 :            :     {
     195                 :     241481 :       gimple_set_modified (s, true);
     196                 :     241481 :       update_stmt_operands (fn, s);
     197                 :            :     }
     198                 :            : }
     199                 :            : 
     200                 :            : 
     201                 :            : #endif /* GCC_GIMPLE_SSA_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.