Mercurial > hg > CbC > CbC_gcc
annotate gcc/tree-ssanames.c @ 60:bd49c42ec43e
remove unnecessary files
author | Shinji KONO <kono@ie.u-ryukyu.ac.jp> |
---|---|
date | Mon, 15 Feb 2010 17:39:45 +0900 |
parents | 77e2b8dfacca |
children | b7f97abdc517 |
rev | line source |
---|---|
0 | 1 /* Generic routines for manipulating SSA_NAME expressions |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
2 Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
3 Free Software Foundation, Inc. |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
4 |
0 | 5 This file is part of GCC. |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
6 |
0 | 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. | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
11 |
0 | 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. | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
16 |
0 | 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 #include "config.h" | |
22 #include "system.h" | |
23 #include "coretypes.h" | |
24 #include "tm.h" | |
25 #include "tree.h" | |
26 #include "varray.h" | |
27 #include "ggc.h" | |
28 #include "tree-flow.h" | |
29 #include "tree-pass.h" | |
30 | |
31 /* Rewriting a function into SSA form can create a huge number of SSA_NAMEs, | |
32 many of which may be thrown away shortly after their creation if jumps | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
33 were threaded through PHI nodes. |
0 | 34 |
35 While our garbage collection mechanisms will handle this situation, it | |
36 is extremely wasteful to create nodes and throw them away, especially | |
37 when the nodes can be reused. | |
38 | |
39 For PR 8361, we can significantly reduce the number of nodes allocated | |
40 and thus the total amount of memory allocated by managing SSA_NAMEs a | |
41 little. This additionally helps reduce the amount of work done by the | |
42 garbage collector. Similar results have been seen on a wider variety | |
43 of tests (such as the compiler itself). | |
44 | |
45 Right now we maintain our free list on a per-function basis. It may | |
46 or may not make sense to maintain the free list for the duration of | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
47 a compilation unit. |
0 | 48 |
49 External code should rely solely upon HIGHEST_SSA_VERSION and the | |
50 externally defined functions. External code should not know about | |
51 the details of the free list management. | |
52 | |
53 External code should also not assume the version number on nodes is | |
54 monotonically increasing. We reuse the version number when we | |
55 reuse an SSA_NAME expression. This helps keep arrays and bitmaps | |
56 more compact. | |
57 | |
58 We could also use a zone allocator for these objects since they have | |
59 a very well defined lifetime. If someone wants to experiment with that | |
60 this is the place to try it. */ | |
61 | |
62 /* Version numbers with special meanings. We start allocating new version | |
63 numbers after the special ones. */ | |
64 #define UNUSED_NAME_VERSION 0 | |
65 | |
66 #ifdef GATHER_STATISTICS | |
67 unsigned int ssa_name_nodes_reused; | |
68 unsigned int ssa_name_nodes_created; | |
69 #endif | |
70 | |
71 /* Initialize management of SSA_NAMEs to default SIZE. If SIZE is | |
72 zero use default. */ | |
73 | |
74 void | |
75 init_ssanames (struct function *fn, int size) | |
76 { | |
77 if (size < 50) | |
78 size = 50; | |
79 | |
80 SSANAMES (fn) = VEC_alloc (tree, gc, size); | |
81 | |
82 /* Version 0 is special, so reserve the first slot in the table. Though | |
83 currently unused, we may use version 0 in alias analysis as part of | |
84 the heuristics used to group aliases when the alias sets are too | |
85 large. | |
86 | |
87 We use VEC_quick_push here because we know that SSA_NAMES has at | |
88 least 50 elements reserved in it. */ | |
89 VEC_quick_push (tree, SSANAMES (fn), NULL_TREE); | |
90 FREE_SSANAMES (fn) = NULL; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
91 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
92 SYMS_TO_RENAME (fn) = BITMAP_GGC_ALLOC (); |
0 | 93 } |
94 | |
95 /* Finalize management of SSA_NAMEs. */ | |
96 | |
97 void | |
98 fini_ssanames (void) | |
99 { | |
100 VEC_free (tree, gc, SSANAMES (cfun)); | |
101 FREE_SSANAMES (cfun) = NULL; | |
102 } | |
103 | |
104 /* Dump some simple statistics regarding the re-use of SSA_NAME nodes. */ | |
105 | |
106 #ifdef GATHER_STATISTICS | |
107 void | |
108 ssanames_print_statistics (void) | |
109 { | |
110 fprintf (stderr, "SSA_NAME nodes allocated: %u\n", ssa_name_nodes_created); | |
111 fprintf (stderr, "SSA_NAME nodes reused: %u\n", ssa_name_nodes_reused); | |
112 } | |
113 #endif | |
114 | |
115 /* Return an SSA_NAME node for variable VAR defined in statement STMT | |
116 in function FN. STMT may be an empty statement for artificial | |
117 references (e.g., default definitions created when a variable is | |
118 used without a preceding definition). */ | |
119 | |
120 tree | |
121 make_ssa_name_fn (struct function *fn, tree var, gimple stmt) | |
122 { | |
123 tree t; | |
124 use_operand_p imm; | |
125 | |
126 gcc_assert (DECL_P (var)); | |
127 | |
128 /* If our free list has an element, then use it. */ | |
129 if (FREE_SSANAMES (fn)) | |
130 { | |
131 t = FREE_SSANAMES (fn); | |
132 FREE_SSANAMES (fn) = TREE_CHAIN (FREE_SSANAMES (fn)); | |
133 #ifdef GATHER_STATISTICS | |
134 ssa_name_nodes_reused++; | |
135 #endif | |
136 | |
137 /* The node was cleared out when we put it on the free list, so | |
138 there is no need to do so again here. */ | |
139 gcc_assert (ssa_name (SSA_NAME_VERSION (t)) == NULL); | |
140 VEC_replace (tree, SSANAMES (fn), SSA_NAME_VERSION (t), t); | |
141 } | |
142 else | |
143 { | |
144 t = make_node (SSA_NAME); | |
145 SSA_NAME_VERSION (t) = VEC_length (tree, SSANAMES (fn)); | |
146 VEC_safe_push (tree, gc, SSANAMES (fn), t); | |
147 #ifdef GATHER_STATISTICS | |
148 ssa_name_nodes_created++; | |
149 #endif | |
150 } | |
151 | |
152 TREE_TYPE (t) = TREE_TYPE (var); | |
153 SSA_NAME_VAR (t) = var; | |
154 SSA_NAME_DEF_STMT (t) = stmt; | |
155 SSA_NAME_PTR_INFO (t) = NULL; | |
156 SSA_NAME_IN_FREE_LIST (t) = 0; | |
157 SSA_NAME_IS_DEFAULT_DEF (t) = 0; | |
158 imm = &(SSA_NAME_IMM_USE_NODE (t)); | |
159 imm->use = NULL; | |
160 imm->prev = imm; | |
161 imm->next = imm; | |
162 imm->loc.ssa_name = t; | |
163 | |
164 return t; | |
165 } | |
166 | |
167 | |
168 /* We no longer need the SSA_NAME expression VAR, release it so that | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
169 it may be reused. |
0 | 170 |
171 Note it is assumed that no calls to make_ssa_name will be made | |
172 until all uses of the ssa name are released and that the only | |
173 use of the SSA_NAME expression is to check its SSA_NAME_VAR. All | |
174 other fields must be assumed clobbered. */ | |
175 | |
176 void | |
177 release_ssa_name (tree var) | |
178 { | |
179 if (!var) | |
180 return; | |
181 | |
182 /* Never release the default definition for a symbol. It's a | |
183 special SSA name that should always exist once it's created. */ | |
184 if (SSA_NAME_IS_DEFAULT_DEF (var)) | |
185 return; | |
186 | |
187 /* If VAR has been registered for SSA updating, don't remove it. | |
188 After update_ssa has run, the name will be released. */ | |
189 if (name_registered_for_update_p (var)) | |
190 { | |
191 release_ssa_name_after_update_ssa (var); | |
192 return; | |
193 } | |
194 | |
195 /* release_ssa_name can be called multiple times on a single SSA_NAME. | |
196 However, it should only end up on our free list one time. We | |
197 keep a status bit in the SSA_NAME node itself to indicate it has | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
198 been put on the free list. |
0 | 199 |
200 Note that once on the freelist you can not reference the SSA_NAME's | |
201 defining statement. */ | |
202 if (! SSA_NAME_IN_FREE_LIST (var)) | |
203 { | |
204 tree saved_ssa_name_var = SSA_NAME_VAR (var); | |
205 int saved_ssa_name_version = SSA_NAME_VERSION (var); | |
206 use_operand_p imm = &(SSA_NAME_IMM_USE_NODE (var)); | |
207 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
208 if (MAY_HAVE_DEBUG_STMTS) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
209 insert_debug_temp_for_var_def (NULL, var); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
210 |
0 | 211 #ifdef ENABLE_CHECKING |
212 verify_imm_links (stderr, var); | |
213 #endif | |
214 while (imm->next != imm) | |
215 delink_imm_use (imm->next); | |
216 | |
217 VEC_replace (tree, SSANAMES (cfun), | |
218 SSA_NAME_VERSION (var), NULL_TREE); | |
219 memset (var, 0, tree_size (var)); | |
220 | |
221 imm->prev = imm; | |
222 imm->next = imm; | |
223 imm->loc.ssa_name = var; | |
224 | |
225 /* First put back the right tree node so that the tree checking | |
226 macros do not complain. */ | |
227 TREE_SET_CODE (var, SSA_NAME); | |
228 | |
229 /* Restore the version number. */ | |
230 SSA_NAME_VERSION (var) = saved_ssa_name_version; | |
231 | |
232 /* Hopefully this can go away once we have the new incremental | |
233 SSA updating code installed. */ | |
234 SSA_NAME_VAR (var) = saved_ssa_name_var; | |
235 | |
236 /* Note this SSA_NAME is now in the first list. */ | |
237 SSA_NAME_IN_FREE_LIST (var) = 1; | |
238 | |
239 /* And finally link it into the free list. */ | |
240 TREE_CHAIN (var) = FREE_SSANAMES (cfun); | |
241 FREE_SSANAMES (cfun) = var; | |
242 } | |
243 } | |
244 | |
245 /* Creates a duplicate of a ssa name NAME defined in statement STMT. */ | |
246 | |
247 tree | |
248 duplicate_ssa_name (tree name, gimple stmt) | |
249 { | |
250 tree new_name = make_ssa_name (SSA_NAME_VAR (name), stmt); | |
251 struct ptr_info_def *old_ptr_info = SSA_NAME_PTR_INFO (name); | |
252 | |
253 if (old_ptr_info) | |
254 duplicate_ssa_name_ptr_info (new_name, old_ptr_info); | |
255 | |
256 return new_name; | |
257 } | |
258 | |
259 | |
260 /* Creates a duplicate of the ptr_info_def at PTR_INFO for use by | |
261 the SSA name NAME. */ | |
262 | |
263 void | |
264 duplicate_ssa_name_ptr_info (tree name, struct ptr_info_def *ptr_info) | |
265 { | |
266 struct ptr_info_def *new_ptr_info; | |
267 | |
268 gcc_assert (POINTER_TYPE_P (TREE_TYPE (name))); | |
269 gcc_assert (!SSA_NAME_PTR_INFO (name)); | |
270 | |
271 if (!ptr_info) | |
272 return; | |
273 | |
274 new_ptr_info = GGC_NEW (struct ptr_info_def); | |
275 *new_ptr_info = *ptr_info; | |
276 | |
277 SSA_NAME_PTR_INFO (name) = new_ptr_info; | |
278 } | |
279 | |
280 | |
281 /* Release all the SSA_NAMEs created by STMT. */ | |
282 | |
283 void | |
284 release_defs (gimple stmt) | |
285 { | |
286 tree def; | |
287 ssa_op_iter iter; | |
288 | |
289 /* Make sure that we are in SSA. Otherwise, operand cache may point | |
290 to garbage. */ | |
291 gcc_assert (gimple_in_ssa_p (cfun)); | |
292 | |
293 FOR_EACH_SSA_TREE_OPERAND (def, stmt, iter, SSA_OP_ALL_DEFS) | |
294 if (TREE_CODE (def) == SSA_NAME) | |
295 release_ssa_name (def); | |
296 } | |
297 | |
298 | |
299 /* Replace the symbol associated with SSA_NAME with SYM. */ | |
300 | |
301 void | |
302 replace_ssa_name_symbol (tree ssa_name, tree sym) | |
303 { | |
304 SSA_NAME_VAR (ssa_name) = sym; | |
305 TREE_TYPE (ssa_name) = TREE_TYPE (sym); | |
306 } | |
307 | |
308 /* Return SSA names that are unused to GGC memory. This is used to keep | |
309 footprint of compiler during interprocedural optimization. | |
310 As a side effect the SSA_NAME_VERSION number reuse is reduced | |
311 so this function should not be used too often. */ | |
312 static unsigned int | |
313 release_dead_ssa_names (void) | |
314 { | |
315 tree t, next; | |
316 int n = 0; | |
317 referenced_var_iterator rvi; | |
318 | |
319 /* Current defs point to various dead SSA names that in turn points to dead | |
320 statements so bunch of dead memory is held from releasing. */ | |
321 FOR_EACH_REFERENCED_VAR (t, rvi) | |
322 set_current_def (t, NULL); | |
323 /* Now release the freelist. */ | |
324 for (t = FREE_SSANAMES (cfun); t; t = next) | |
325 { | |
326 next = TREE_CHAIN (t); | |
327 /* Dangling pointers might make GGC to still see dead SSA names, so it is | |
328 important to unlink the list and avoid GGC from seeing all subsequent | |
329 SSA names. In longer run we want to have all dangling pointers here | |
330 removed (since they usually go through dead statements that consume | |
331 considerable amounts of memory). */ | |
332 TREE_CHAIN (t) = NULL_TREE; | |
333 n++; | |
334 } | |
335 FREE_SSANAMES (cfun) = NULL; | |
336 | |
337 /* Cgraph edges has been invalidated and point to dead statement. We need to | |
338 remove them now and will rebuild it before next IPA pass. */ | |
339 cgraph_node_remove_callees (cgraph_node (current_function_decl)); | |
340 | |
341 if (dump_file) | |
342 fprintf (dump_file, "Released %i names, %.2f%%\n", n, n * 100.0 / num_ssa_names); | |
343 return 0; | |
344 } | |
345 | |
346 struct gimple_opt_pass pass_release_ssa_names = | |
347 { | |
348 { | |
349 GIMPLE_PASS, | |
350 "release_ssa", /* name */ | |
351 NULL, /* gate */ | |
352 release_dead_ssa_names, /* execute */ | |
353 NULL, /* sub */ | |
354 NULL, /* next */ | |
355 0, /* static_pass_number */ | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
356 TV_NONE, /* tv_id */ |
0 | 357 PROP_ssa, /* properties_required */ |
358 0, /* properties_provided */ | |
359 0, /* properties_destroyed */ | |
360 0, /* todo_flags_start */ | |
361 TODO_dump_func /* todo_flags_finish */ | |
362 } | |
363 }; |