gcc/gimple-ssa.h

   1 /* Header file for routines that straddle the border between GIMPLE and
   2    SSA in gimple.
   3    Copyright (C) 2009-2024 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   static hashval_t hash (tm_restart_node *n) { return htab_hash_pointer (n); }
  39
  40   static bool
  41   equal (tm_restart_node *a, tm_restart_node *b)
  42   {
  43     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   hash (tree item)
  56   {
  57     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   equal (tree a, tree b)
  64 {
  65   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 and ESCAPED_RETURN artificial
  80      variables.  */
  81   struct pt_solution escaped;
  82   struct pt_solution escaped_return;
  83
  84   /* A map of decls to artificial ssa-names that point to the partition
  85      of the decl.  */
  86   hash_map<tree, tree> * GTY((skip(""))) decls_to_pointers;
  87
  88   /* Free list of SSA_NAMEs.  */
  89   vec<tree, va_gc> *free_ssanames;
  90
  91   /* Queue of SSA_NAMEs to be freed at the next opportunity.  */
  92   vec<tree, va_gc> *free_ssanames_queue;
  93
  94   /* Hashtable holding definition for symbol.  If this field is not NULL, it
  95      means that the first reference to this variable in the function is a
  96      USE or a VUSE.  In those cases, the SSA renamer creates an SSA name
  97      for this variable with an empty defining statement.  */
  98   hash_table<ssa_name_hasher> *default_defs;
  99
 100   /* True if there are any symbols that need to be renamed.  */
 101   unsigned int ssa_renaming_needed : 1;
 102
 103   /* True if all virtual operands need to be renamed.  */
 104   unsigned int rename_vops : 1;
 105
 106   /* True if the code is in ssa form.  */
 107   unsigned int in_ssa_p : 1;
 108
 109   /* True if IPA points-to information was computed for this function.  */
 110   unsigned int ipa_pta : 1;
 111
 112   struct ssa_operands ssa_operands;
 113
 114   /* Map gimple stmt to tree label (or list of labels) for transaction
 115      restart and abort.  */
 116   hash_table<tm_restart_hasher> *tm_restart;
 117 };
 118
 119
 120 /* Return true when gimple SSA form was built.
 121    gimple_in_ssa_p is queried by gimplifier in various early stages before SSA
 122    infrastructure is initialized.  Check for presence of the datastructures
 123    at first place.  */
 124 inline bool
 125 gimple_in_ssa_p (const struct function *fun)
 126 {
 127   return fun && fun->gimple_df && fun->gimple_df->in_ssa_p;
 128 }
 129
 130 /* Artificial variable used for the virtual operand FUD chain.  */
 131 inline tree
 132 gimple_vop (const struct function *fun)
 133 {
 134   gcc_checking_assert (fun && fun->gimple_df);
 135   return fun->gimple_df->vop;
 136 }
 137
 138 /* Return the set of VUSE operand for statement G.  */
 139
 140 inline use_operand_p
 141 gimple_vuse_op (const gimple *g)
 142 {
 143   struct use_optype_d *ops;
 144   const gimple_statement_with_memory_ops *mem_ops_stmt =
 145      dyn_cast <const gimple_statement_with_memory_ops *> (g);
 146   if (!mem_ops_stmt)
 147     return NULL_USE_OPERAND_P;
 148   ops = mem_ops_stmt->use_ops;
 149   if (ops
 150       && USE_OP_PTR (ops)->use == &mem_ops_stmt->vuse)
 151     return USE_OP_PTR (ops);
 152   return NULL_USE_OPERAND_P;
 153 }
 154
 155 /* Return the set of VDEF operand for statement G.  */
 156
 157 inline def_operand_p
 158 gimple_vdef_op (gimple *g)
 159 {
 160   gimple_statement_with_memory_ops *mem_ops_stmt =
 161      dyn_cast <gimple_statement_with_memory_ops *> (g);
 162   if (!mem_ops_stmt)
 163     return NULL_DEF_OPERAND_P;
 164   if (mem_ops_stmt->vdef)
 165     return &mem_ops_stmt->vdef;
 166   return NULL_DEF_OPERAND_P;
 167 }
 168
 169 /* Mark statement S as modified, and update it.  */
 170
 171 inline void
 172 update_stmt (gimple *s)
 173 {
 174   if (gimple_has_ops (s))
 175     {
 176       gimple_set_modified (s, true);
 177       update_stmt_operands (cfun, s);
 178     }
 179 }
 180
 181 /* Update statement S if it has been optimized.  */
 182
 183 inline void
 184 update_stmt_if_modified (gimple *s)
 185 {
 186   if (gimple_modified_p (s))
 187     update_stmt_operands (cfun, s);
 188 }
 189
 190 /* Mark statement S as modified, and update it.  */
 191
 192 inline void
 193 update_stmt_fn (struct function *fn, gimple *s)
 194 {
 195   if (gimple_has_ops (s))
 196     {
 197       gimple_set_modified (s, true);
 198       update_stmt_operands (fn, s);
 199     }
 200 }
 201
 202
 203 #endif /* GCC_GIMPLE_SSA_H */