Mercurial > hg > CbC > CbC_gcc
comparison gcc/gimple-ssa.h @ 111:04ced10e8804
gcc 7
author | kono |
---|---|
date | Fri, 27 Oct 2017 22:46:09 +0900 |
parents | |
children | 84e7813d76e9 |
comparison
equal
deleted
inserted
replaced
68:561a7518be6b | 111:04ced10e8804 |
---|---|
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 | |
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 */ |