1/* Header file for routines that straddle the border between GIMPLE and
2 SSA in gimple.
3 Copyright (C) 2009-2017 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 "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
29struct GTY((for_user)) tm_restart_node {
30 gimple *stmt;
31 tree label_or_list;
32};
33
34/* Hasher for tm_restart_node. */
35
36struct 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
47extern void gt_ggc_mx (gimple *&);
48extern void gt_pch_nx (gimple *&);
49
50struct 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. */
72struct 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. */
122static inline bool
123gimple_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. */
129static inline tree
130gimple_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
138static inline use_operand_p
139gimple_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
155static inline def_operand_p
156gimple_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
169static inline void
170update_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
181static inline void
182update_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
190static inline void
191update_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