1 /* Header file for routines that straddle the border between GIMPLE and 2 SSA in gimple. 3 Copyright (C) 2009-2018 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 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 gimple_in_ssa_p (const struct function *fun) 124 { 125 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 gimple_vop (const struct function *fun) 131 { 132 gcc_checking_assert (fun && fun->gimple_df); 133 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 gimple_vuse_op (const gimple *g) 140 { 141 struct use_optype_d *ops; 142 const gimple_statement_with_memory_ops *mem_ops_stmt = 143 dyn_cast <const gimple_statement_with_memory_ops *> (g); 144 if (!mem_ops_stmt) 145 return NULL_USE_OPERAND_P; 146 ops = mem_ops_stmt->use_ops; 147 if (ops 148 && USE_OP_PTR (ops)->use == &mem_ops_stmt->vuse) 149 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 update_stmt (gimple *s) 171 { 172 if (gimple_has_ops (s)) 173 { 174 gimple_set_modified (s, true); 175 update_stmt_operands (cfun, s); 176 } 177 } 178 179 /* Update statement S if it has been optimized. */ 180 181 static inline void 182 update_stmt_if_modified (gimple *s) 183 { 184 if (gimple_modified_p (s)) 185 update_stmt_operands (cfun, s); 186 } 187 188 /* Mark statement S as modified, and update it. */ 189 190 static inline void 191 update_stmt_fn (struct function *fn, gimple *s) 192 { 193 if (gimple_has_ops (s)) 194 { 195 gimple_set_modified (s, true); 196 update_stmt_operands (fn, s); 197 } 198 } 199 200 201 #endif /* GCC_GIMPLE_SSA_H */ 202