Daily bump.
[official-gcc.git] / gcc / gimple-ssa.h
blobd2e62a94b378d074ecdace5ccd52f9aa8da8524c
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.
5 This file is part of GCC.
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.
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.
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/>. */
21 #ifndef GCC_GIMPLE_SSA_H
22 #define GCC_GIMPLE_SSA_H
24 #include "hash-map.h"
25 #include "tree-ssa-operands.h"
27 /* This structure is used to map a gimple statement to a label,
28 or list of labels to represent transaction restart. */
30 struct GTY(()) tm_restart_node {
31 gimple stmt;
32 tree label_or_list;
35 /* Gimple dataflow datastructure. All publicly available fields shall have
36 gimple_ accessor defined, all publicly modifiable fields should have
37 gimple_set accessor. */
38 struct GTY(()) gimple_df {
39 /* A vector of all the noreturn calls passed to modify_stmt.
40 cleanup_control_flow uses it to detect cases where a mid-block
41 indirect call has been turned into a noreturn call. When this
42 happens, all the instructions after the call are no longer
43 reachable and must be deleted as dead. */
44 vec<gimple, va_gc> *modified_noreturn_calls;
46 /* Array of all SSA_NAMEs used in the function. */
47 vec<tree, va_gc> *ssa_names;
49 /* Artificial variable used for the virtual operand FUD chain. */
50 tree vop;
52 /* The PTA solution for the ESCAPED artificial variable. */
53 struct pt_solution escaped;
55 /* A map of decls to artificial ssa-names that point to the partition
56 of the decl. */
57 hash_map<tree, tree> * GTY((skip(""))) decls_to_pointers;
59 /* Free list of SSA_NAMEs. */
60 vec<tree, va_gc> *free_ssanames;
62 /* Hashtable holding definition for symbol. If this field is not NULL, it
63 means that the first reference to this variable in the function is a
64 USE or a VUSE. In those cases, the SSA renamer creates an SSA name
65 for this variable with an empty defining statement. */
66 htab_t GTY((param_is (union tree_node))) default_defs;
68 /* True if there are any symbols that need to be renamed. */
69 unsigned int ssa_renaming_needed : 1;
71 /* True if all virtual operands need to be renamed. */
72 unsigned int rename_vops : 1;
74 /* True if the code is in ssa form. */
75 unsigned int in_ssa_p : 1;
77 /* True if IPA points-to information was computed for this function. */
78 unsigned int ipa_pta : 1;
80 struct ssa_operands ssa_operands;
82 /* Map gimple stmt to tree label (or list of labels) for transaction
83 restart and abort. */
84 htab_t GTY ((param_is (struct tm_restart_node))) tm_restart;
88 /* Return true when gimple SSA form was built.
89 gimple_in_ssa_p is queried by gimplifier in various early stages before SSA
90 infrastructure is initialized. Check for presence of the datastructures
91 at first place. */
92 static inline bool
93 gimple_in_ssa_p (const struct function *fun)
95 return fun && fun->gimple_df && fun->gimple_df->in_ssa_p;
98 /* Artificial variable used for the virtual operand FUD chain. */
99 static inline tree
100 gimple_vop (const struct function *fun)
102 gcc_checking_assert (fun && fun->gimple_df);
103 return fun->gimple_df->vop;
106 /* Return the set of VUSE operand for statement G. */
108 static inline use_operand_p
109 gimple_vuse_op (const_gimple g)
111 struct use_optype_d *ops;
112 const gimple_statement_with_memory_ops *mem_ops_stmt =
113 dyn_cast <const gimple_statement_with_memory_ops *> (g);
114 if (!mem_ops_stmt)
115 return NULL_USE_OPERAND_P;
116 ops = mem_ops_stmt->use_ops;
117 if (ops
118 && USE_OP_PTR (ops)->use == &mem_ops_stmt->vuse)
119 return USE_OP_PTR (ops);
120 return NULL_USE_OPERAND_P;
123 /* Return the set of VDEF operand for statement G. */
125 static inline def_operand_p
126 gimple_vdef_op (gimple g)
128 gimple_statement_with_memory_ops *mem_ops_stmt =
129 dyn_cast <gimple_statement_with_memory_ops *> (g);
130 if (!mem_ops_stmt)
131 return NULL_DEF_OPERAND_P;
132 if (mem_ops_stmt->vdef)
133 return &mem_ops_stmt->vdef;
134 return NULL_DEF_OPERAND_P;
137 /* Mark statement S as modified, and update it. */
139 static inline void
140 update_stmt (gimple s)
142 if (gimple_has_ops (s))
144 gimple_set_modified (s, true);
145 update_stmt_operands (cfun, s);
149 /* Update statement S if it has been optimized. */
151 static inline void
152 update_stmt_if_modified (gimple s)
154 if (gimple_modified_p (s))
155 update_stmt_operands (cfun, s);
158 /* Mark statement S as modified, and update it. */
160 static inline void
161 update_stmt_fn (struct function *fn, gimple s)
163 if (gimple_has_ops (s))
165 gimple_set_modified (s, true);
166 update_stmt_operands (fn, s);
171 #endif /* GCC_GIMPLE_SSA_H */