1/* Header file for routines that straddle the border between GIMPLE and 2 SSA in gimple. 3 Copyright (C) 2009-2015 Free Software Foundation, Inc. 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 3, or (at your option) 10any later version. 11 12GCC is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along 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 "hash-map.h" 25#include "tree-hasher.h" 26#include "tree-ssa-operands.h" 27 28/* This structure is used to map a gimple statement to a label, 29 or list of labels to represent transaction restart. */ 30 31struct GTY((for_user)) tm_restart_node { 32 gimple stmt; 33 tree label_or_list; 34}; 35 36/* Hasher for tm_restart_node. */ 37 38struct tm_restart_hasher : ggc_hasher<tm_restart_node *> 39{ 40 static hashval_t hash (tm_restart_node *n) { return htab_hash_pointer (n); } 41 42 static bool 43 equal (tm_restart_node *a, tm_restart_node *b) 44 { 45 return a == b; 46 } 47}; 48 49struct ssa_name_hasher : ggc_hasher<tree> 50{ 51 /* Hash a tree in a uid_decl_map. */ 52 53 static hashval_t 54 hash (tree item) 55 { 56 return item->ssa_name.var->decl_minimal.uid; 57 } 58 59 /* Return true if the DECL_UID in both trees are equal. */ 60 61 static bool 62 equal (tree a, tree b) 63{ 64 return (a->ssa_name.var->decl_minimal.uid == b->ssa_name.var->decl_minimal.uid); 65} 66}; 67 68/* Gimple dataflow datastructure. All publicly available fields shall have 69 gimple_ accessor defined, all publicly modifiable fields should have 70 gimple_set accessor. */ 71struct GTY(()) gimple_df { 72 /* A vector of all the noreturn calls passed to modify_stmt. 73 cleanup_control_flow uses it to detect cases where a mid-block 74 indirect call has been turned into a noreturn call. When this 75 happens, all the instructions after the call are no longer 76 reachable and must be deleted as dead. */ 77 vec<gimple, va_gc> *modified_noreturn_calls; 78 79 /* Array of all SSA_NAMEs used in the function. */ 80 vec<tree, va_gc> *ssa_names; 81 82 /* Artificial variable used for the virtual operand FUD chain. */ 83 tree vop; 84 85 /* The PTA solution for the ESCAPED artificial variable. */ 86 struct pt_solution escaped; 87 88 /* A map of decls to artificial ssa-names that point to the partition 89 of the decl. */ 90 hash_map<tree, tree> * GTY((skip(""))) decls_to_pointers; 91 92 /* Free list of SSA_NAMEs. */ 93 vec<tree, va_gc> *free_ssanames; 94 95 /* Hashtable holding definition for symbol. If this field is not NULL, it 96 means that the first reference to this variable in the function is a 97 USE or a VUSE. In those cases, the SSA renamer creates an SSA name 98 for this variable with an empty defining statement. */ 99 hash_table<ssa_name_hasher> *default_defs; 100 101 /* True if there are any symbols that need to be renamed. */ 102 unsigned int ssa_renaming_needed : 1; 103 104 /* True if all virtual operands need to be renamed. */ 105 unsigned int rename_vops : 1; 106 107 /* True if the code is in ssa form. */ 108 unsigned int in_ssa_p : 1; 109 110 /* True if IPA points-to information was computed for this function. */ 111 unsigned int ipa_pta : 1; 112 113 struct ssa_operands ssa_operands; 114 115 /* Map gimple stmt to tree label (or list of labels) for transaction 116 restart and abort. */ 117 hash_table<tm_restart_hasher> *tm_restart; 118}; 119 120 121/* Return true when gimple SSA form was built. 122 gimple_in_ssa_p is queried by gimplifier in various early stages before SSA 123 infrastructure is initialized. Check for presence of the datastructures 124 at first place. */ 125static inline bool 126gimple_in_ssa_p (const struct function *fun) 127{ 128 return fun && fun->gimple_df && fun->gimple_df->in_ssa_p; 129} 130 131/* Artificial variable used for the virtual operand FUD chain. */ 132static inline tree 133gimple_vop (const struct function *fun) 134{ 135 gcc_checking_assert (fun && fun->gimple_df); 136 return fun->gimple_df->vop; 137} 138 139/* Return the set of VUSE operand for statement G. */ 140 141static inline use_operand_p 142gimple_vuse_op (const_gimple g) 143{ 144 struct use_optype_d *ops; 145 const gimple_statement_with_memory_ops *mem_ops_stmt = 146 dyn_cast <const gimple_statement_with_memory_ops *> (g); 147 if (!mem_ops_stmt) 148 return NULL_USE_OPERAND_P; 149 ops = mem_ops_stmt->use_ops; 150 if (ops 151 && USE_OP_PTR (ops)->use == &mem_ops_stmt->vuse) 152 return USE_OP_PTR (ops); 153 return NULL_USE_OPERAND_P; 154} 155 156/* Return the set of VDEF operand for statement G. */ 157 158static inline def_operand_p 159gimple_vdef_op (gimple g) 160{ 161 gimple_statement_with_memory_ops *mem_ops_stmt = 162 dyn_cast <gimple_statement_with_memory_ops *> (g); 163 if (!mem_ops_stmt) 164 return NULL_DEF_OPERAND_P; 165 if (mem_ops_stmt->vdef) 166 return &mem_ops_stmt->vdef; 167 return NULL_DEF_OPERAND_P; 168} 169 170/* Mark statement S as modified, and update it. */ 171 172static inline void 173update_stmt (gimple s) 174{ 175 if (gimple_has_ops (s)) 176 { 177 gimple_set_modified (s, true); 178 update_stmt_operands (cfun, s); 179 } 180} 181 182/* Update statement S if it has been optimized. */ 183 184static inline void 185update_stmt_if_modified (gimple s) 186{ 187 if (gimple_modified_p (s)) 188 update_stmt_operands (cfun, s); 189} 190 191/* Mark statement S as modified, and update it. */ 192 193static inline void 194update_stmt_fn (struct function *fn, gimple s) 195{ 196 if (gimple_has_ops (s)) 197 { 198 gimple_set_modified (s, true); 199 update_stmt_operands (fn, s); 200 } 201} 202 203 204#endif /* GCC_GIMPLE_SSA_H */ 205