gcc/gimple-ssa.h

   1 /* Header file for routines that straddle the border between GIMPLE and
   2    SSA in gimple.
   3    Copyright (C) 2009-2014 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(()) tm_restart_node {
  30   gimple stmt;
  31   tree label_or_list;
  32 };
  33
  34 /* Gimple dataflow datastructure. All publicly available fields shall have
  35    gimple_ accessor defined, all publicly modifiable fields should have
  36    gimple_set accessor.  */
  37 struct GTY(()) gimple_df {
  38   /* A vector of all the noreturn calls passed to modify_stmt.
  39      cleanup_control_flow uses it to detect cases where a mid-block
  40      indirect call has been turned into a noreturn call.  When this
  41      happens, all the instructions after the call are no longer
  42      reachable and must be deleted as dead.  */
  43   vec<gimple, va_gc> *modified_noreturn_calls;
  44
  45   /* Array of all SSA_NAMEs used in the function.  */
  46   vec<tree, va_gc> *ssa_names;
  47
  48   /* Artificial variable used for the virtual operand FUD chain.  */
  49   tree vop;
  50
  51   /* The PTA solution for the ESCAPED artificial variable.  */
  52   struct pt_solution escaped;
  53
  54   /* A map of decls to artificial ssa-names that point to the partition
  55      of the decl.  */
  56   struct pointer_map_t * GTY((skip(""))) decls_to_pointers;
  57
  58   /* Free list of SSA_NAMEs.  */
  59   vec<tree, va_gc> *free_ssanames;
  60
  61   /* Hashtable holding definition for symbol.  If this field is not NULL, it
  62      means that the first reference to this variable in the function is a
  63      USE or a VUSE.  In those cases, the SSA renamer creates an SSA name
  64      for this variable with an empty defining statement.  */
  65   htab_t GTY((param_is (union tree_node))) default_defs;
  66
  67   /* True if there are any symbols that need to be renamed.  */
  68   unsigned int ssa_renaming_needed : 1;
  69
  70   /* True if all virtual operands need to be renamed.  */
  71   unsigned int rename_vops : 1;
  72
  73   /* True if the code is in ssa form.  */
  74   unsigned int in_ssa_p : 1;
  75
  76   /* True if IPA points-to information was computed for this function.  */
  77   unsigned int ipa_pta : 1;
  78
  79   struct ssa_operands ssa_operands;
  80
  81   /* Map gimple stmt to tree label (or list of labels) for transaction
  82      restart and abort.  */
  83   htab_t GTY ((param_is (struct tm_restart_node))) tm_restart;
  84 };
  85
  86
  87 /* Return true when gimple SSA form was built.
  88    gimple_in_ssa_p is queried by gimplifier in various early stages before SSA
  89    infrastructure is initialized.  Check for presence of the datastructures
  90    at first place.  */
  91 static inline bool
  92 gimple_in_ssa_p (const struct function *fun)
  93 {
  94   return fun && fun->gimple_df && fun->gimple_df->in_ssa_p;
  95 }
  96
  97 /* Artificial variable used for the virtual operand FUD chain.  */
  98 static inline tree
  99 gimple_vop (const struct function *fun)
 100 {
 101   gcc_checking_assert (fun && fun->gimple_df);
 102   return fun->gimple_df->vop;
 103 }
 104
 105 /* Return the set of VUSE operand for statement G.  */
 106
 107 static inline use_operand_p
 108 gimple_vuse_op (const_gimple g)
 109 {
 110   struct use_optype_d *ops;
 111   const gimple_statement_with_memory_ops *mem_ops_stmt =
 112      dyn_cast <const gimple_statement_with_memory_ops *> (g);
 113   if (!mem_ops_stmt)
 114     return NULL_USE_OPERAND_P;
 115   ops = mem_ops_stmt->use_ops;
 116   if (ops
 117       && USE_OP_PTR (ops)->use == &mem_ops_stmt->vuse)
 118     return USE_OP_PTR (ops);
 119   return NULL_USE_OPERAND_P;
 120 }
 121
 122 /* Return the set of VDEF operand for statement G.  */
 123
 124 static inline def_operand_p
 125 gimple_vdef_op (gimple g)
 126 {
 127   gimple_statement_with_memory_ops *mem_ops_stmt =
 128      dyn_cast <gimple_statement_with_memory_ops *> (g);
 129   if (!mem_ops_stmt)
 130     return NULL_DEF_OPERAND_P;
 131   if (mem_ops_stmt->vdef)
 132     return &mem_ops_stmt->vdef;
 133   return NULL_DEF_OPERAND_P;
 134 }
 135
 136 /* Mark statement S as modified, and update it.  */
 137
 138 static inline void
 139 update_stmt (gimple s)
 140 {
 141   if (gimple_has_ops (s))
 142     {
 143       gimple_set_modified (s, true);
 144       update_stmt_operands (cfun, s);
 145     }
 146 }
 147
 148 /* Update statement S if it has been optimized.  */
 149
 150 static inline void
 151 update_stmt_if_modified (gimple s)
 152 {
 153   if (gimple_modified_p (s))
 154     update_stmt_operands (cfun, s);
 155 }
 156
 157 /* Mark statement S as modified, and update it.  */
 158
 159 static inline void
 160 update_stmt_fn (struct function *fn, gimple s)
 161 {
 162   if (gimple_has_ops (s))
 163     {
 164       gimple_set_modified (s, true);
 165       update_stmt_operands (fn, s);
 166     }
 167 }
 168
 169
 170 #endif /* GCC_GIMPLE_SSA_H */