Mercurial > hg > CbC > CbC_gcc
comparison gcc/cgraph.h @ 0:a06113de4d67
first commit
author | kent <kent@cr.ie.u-ryukyu.ac.jp> |
---|---|
date | Fri, 17 Jul 2009 14:47:48 +0900 |
parents | |
children | 77e2b8dfacca |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:a06113de4d67 |
---|---|
1 /* Callgraph handling code. | |
2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008 | |
3 Free Software Foundation, Inc. | |
4 Contributed by Jan Hubicka | |
5 | |
6 This file is part of GCC. | |
7 | |
8 GCC is free software; you can redistribute it and/or modify it under | |
9 the terms of the GNU General Public License as published by the Free | |
10 Software Foundation; either version 3, or (at your option) any later | |
11 version. | |
12 | |
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
16 for more details. | |
17 | |
18 You should have received a copy of the GNU General Public License | |
19 along with GCC; see the file COPYING3. If not see | |
20 <http://www.gnu.org/licenses/>. */ | |
21 | |
22 #ifndef GCC_CGRAPH_H | |
23 #define GCC_CGRAPH_H | |
24 #include "tree.h" | |
25 #include "basic-block.h" | |
26 | |
27 enum availability | |
28 { | |
29 /* Not yet set by cgraph_function_body_availability. */ | |
30 AVAIL_UNSET, | |
31 /* Function body/variable initializer is unknown. */ | |
32 AVAIL_NOT_AVAILABLE, | |
33 /* Function body/variable initializer is known but might be replaced | |
34 by a different one from other compilation unit and thus needs to | |
35 be dealt with a care. Like AVAIL_NOT_AVAILABLE it can have | |
36 arbitrary side effects on escaping variables and functions, while | |
37 like AVAILABLE it might access static variables. */ | |
38 AVAIL_OVERWRITABLE, | |
39 /* Function body/variable initializer is known and will be used in final | |
40 program. */ | |
41 AVAIL_AVAILABLE, | |
42 /* Function body/variable initializer is known and all it's uses are explicitly | |
43 visible within current unit (ie it's address is never taken and it is not | |
44 exported to other units). | |
45 Currently used only for functions. */ | |
46 AVAIL_LOCAL | |
47 }; | |
48 | |
49 extern const char * const cgraph_availability_names[]; | |
50 | |
51 /* Information about the function collected locally. | |
52 Available after function is analyzed. */ | |
53 | |
54 struct cgraph_local_info GTY(()) | |
55 { | |
56 struct inline_summary { | |
57 /* Estimated stack frame consumption by the function. */ | |
58 HOST_WIDE_INT estimated_self_stack_size; | |
59 | |
60 /* Size of the function before inlining. */ | |
61 int self_insns; | |
62 } inline_summary; | |
63 | |
64 /* Set when function function is visible in current compilation unit only | |
65 and its address is never taken. */ | |
66 unsigned local : 1; | |
67 | |
68 /* Set when function is visible by other units. */ | |
69 unsigned externally_visible : 1; | |
70 | |
71 /* Set once it has been finalized so we consider it to be output. */ | |
72 unsigned finalized : 1; | |
73 | |
74 /* False when there something makes inlining impossible (such as va_arg). */ | |
75 unsigned inlinable : 1; | |
76 | |
77 /* True when function should be inlined independently on its size. */ | |
78 unsigned disregard_inline_limits : 1; | |
79 | |
80 /* True when the function has been originally extern inline, but it is | |
81 redefined now. */ | |
82 unsigned redefined_extern_inline : 1; | |
83 | |
84 /* True if statics_read_for_function and | |
85 statics_written_for_function contain valid data. */ | |
86 unsigned for_functions_valid : 1; | |
87 | |
88 /* True if the function is going to be emitted in some other translation | |
89 unit, referenced from vtable. */ | |
90 unsigned vtable_method : 1; | |
91 }; | |
92 | |
93 /* Information about the function that needs to be computed globally | |
94 once compilation is finished. Available only with -funit-at-a-time. */ | |
95 | |
96 struct cgraph_global_info GTY(()) | |
97 { | |
98 /* Estimated stack frame consumption by the function. */ | |
99 HOST_WIDE_INT estimated_stack_size; | |
100 /* Expected offset of the stack frame of inlined function. */ | |
101 HOST_WIDE_INT stack_frame_offset; | |
102 | |
103 /* For inline clones this points to the function they will be | |
104 inlined into. */ | |
105 struct cgraph_node *inlined_to; | |
106 | |
107 /* Estimated size of the function after inlining. */ | |
108 int insns; | |
109 | |
110 /* Estimated growth after inlining. INT_MIN if not computed. */ | |
111 int estimated_growth; | |
112 | |
113 /* Set iff the function has been inlined at least once. */ | |
114 bool inlined; | |
115 }; | |
116 | |
117 /* Information about the function that is propagated by the RTL backend. | |
118 Available only for functions that has been already assembled. */ | |
119 | |
120 struct cgraph_rtl_info GTY(()) | |
121 { | |
122 unsigned int preferred_incoming_stack_boundary; | |
123 }; | |
124 | |
125 /* The cgraph data structure. | |
126 Each function decl has assigned cgraph_node listing callees and callers. */ | |
127 | |
128 struct cgraph_node GTY((chain_next ("%h.next"), chain_prev ("%h.previous"))) | |
129 { | |
130 tree decl; | |
131 struct cgraph_edge *callees; | |
132 struct cgraph_edge *callers; | |
133 struct cgraph_node *next; | |
134 struct cgraph_node *previous; | |
135 /* For nested functions points to function the node is nested in. */ | |
136 struct cgraph_node *origin; | |
137 /* Points to first nested function, if any. */ | |
138 struct cgraph_node *nested; | |
139 /* Pointer to the next function with same origin, if any. */ | |
140 struct cgraph_node *next_nested; | |
141 /* Pointer to the next function in cgraph_nodes_queue. */ | |
142 struct cgraph_node *next_needed; | |
143 /* Pointer to the next clone. */ | |
144 struct cgraph_node *next_clone; | |
145 struct cgraph_node *prev_clone; | |
146 /* Pointer to a single unique cgraph node for this function. If the | |
147 function is to be output, this is the copy that will survive. */ | |
148 struct cgraph_node *master_clone; | |
149 /* For functions with many calls sites it holds map from call expression | |
150 to the edge to speed up cgraph_edge function. */ | |
151 htab_t GTY((param_is (struct cgraph_edge))) call_site_hash; | |
152 | |
153 PTR GTY ((skip)) aux; | |
154 | |
155 struct cgraph_local_info local; | |
156 struct cgraph_global_info global; | |
157 struct cgraph_rtl_info rtl; | |
158 | |
159 /* Expected number of executions: calculated in profile.c. */ | |
160 gcov_type count; | |
161 /* Unique id of the node. */ | |
162 int uid; | |
163 /* Ordering of all cgraph nodes. */ | |
164 int order; | |
165 | |
166 /* unique id for profiling. pid is not suitable because of different | |
167 number of cfg nodes with -fprofile-generate and -fprofile-use */ | |
168 int pid; | |
169 | |
170 /* Set when function must be output - it is externally visible | |
171 or its address is taken. */ | |
172 unsigned needed : 1; | |
173 /* Set when decl is an abstract function pointed to by the | |
174 ABSTRACT_DECL_ORIGIN of a reachable function. */ | |
175 unsigned abstract_and_needed : 1; | |
176 /* Set when function is reachable by call from other function | |
177 that is either reachable or needed. */ | |
178 unsigned reachable : 1; | |
179 /* Set once the function is lowered (i.e. its CFG is built). */ | |
180 unsigned lowered : 1; | |
181 /* Set once the function has been instantiated and its callee | |
182 lists created. */ | |
183 unsigned analyzed : 1; | |
184 /* Set when function is scheduled to be assembled. */ | |
185 unsigned output : 1; | |
186 /* Set for aliases once they got through assemble_alias. */ | |
187 unsigned alias : 1; | |
188 | |
189 /* In non-unit-at-a-time mode the function body of inline candidates is saved | |
190 into clone before compiling so the function in original form can be | |
191 inlined later. This pointer points to the clone. */ | |
192 tree inline_decl; | |
193 }; | |
194 | |
195 struct cgraph_edge GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"))) | |
196 { | |
197 struct cgraph_node *caller; | |
198 struct cgraph_node *callee; | |
199 struct cgraph_edge *prev_caller; | |
200 struct cgraph_edge *next_caller; | |
201 struct cgraph_edge *prev_callee; | |
202 struct cgraph_edge *next_callee; | |
203 gimple call_stmt; | |
204 PTR GTY ((skip (""))) aux; | |
205 /* When NULL, inline this call. When non-NULL, points to the explanation | |
206 why function was not inlined. */ | |
207 const char *inline_failed; | |
208 /* Expected number of executions: calculated in profile.c. */ | |
209 gcov_type count; | |
210 /* Expected frequency of executions within the function. | |
211 When set to CGRAPH_FREQ_BASE, the edge is expected to be called once | |
212 per function call. The range is 0 to CGRAPH_FREQ_MAX. */ | |
213 int frequency; | |
214 /* Depth of loop nest, 1 means no loop nest. */ | |
215 unsigned int loop_nest : 31; | |
216 /* Whether this edge describes a call that was originally indirect. */ | |
217 unsigned int indirect_call : 1; | |
218 /* Unique id of the edge. */ | |
219 int uid; | |
220 }; | |
221 | |
222 #define CGRAPH_FREQ_BASE 1000 | |
223 #define CGRAPH_FREQ_MAX 100000 | |
224 | |
225 typedef struct cgraph_edge *cgraph_edge_p; | |
226 | |
227 DEF_VEC_P(cgraph_edge_p); | |
228 DEF_VEC_ALLOC_P(cgraph_edge_p,heap); | |
229 | |
230 /* The varpool data structure. | |
231 Each static variable decl has assigned varpool_node. */ | |
232 | |
233 struct varpool_node GTY((chain_next ("%h.next"))) | |
234 { | |
235 tree decl; | |
236 /* Pointer to the next function in varpool_nodes. */ | |
237 struct varpool_node *next; | |
238 /* Pointer to the next function in varpool_nodes_queue. */ | |
239 struct varpool_node *next_needed; | |
240 /* Ordering of all cgraph nodes. */ | |
241 int order; | |
242 | |
243 /* Set when function must be output - it is externally visible | |
244 or its address is taken. */ | |
245 unsigned needed : 1; | |
246 /* Needed variables might become dead by optimization. This flag | |
247 forces the variable to be output even if it appears dead otherwise. */ | |
248 unsigned force_output : 1; | |
249 /* Set once the variable has been instantiated and its callee | |
250 lists created. */ | |
251 unsigned analyzed : 1; | |
252 /* Set once it has been finalized so we consider it to be output. */ | |
253 unsigned finalized : 1; | |
254 /* Set when variable is scheduled to be assembled. */ | |
255 unsigned output : 1; | |
256 /* Set when function is visible by other units. */ | |
257 unsigned externally_visible : 1; | |
258 /* Set for aliases once they got through assemble_alias. */ | |
259 unsigned alias : 1; | |
260 }; | |
261 | |
262 /* Every top level asm statement is put into a cgraph_asm_node. */ | |
263 | |
264 struct cgraph_asm_node GTY(()) | |
265 { | |
266 /* Next asm node. */ | |
267 struct cgraph_asm_node *next; | |
268 /* String for this asm node. */ | |
269 tree asm_str; | |
270 /* Ordering of all cgraph nodes. */ | |
271 int order; | |
272 }; | |
273 | |
274 extern GTY(()) struct cgraph_node *cgraph_nodes; | |
275 extern GTY(()) int cgraph_n_nodes; | |
276 extern GTY(()) int cgraph_max_uid; | |
277 extern GTY(()) int cgraph_edge_max_uid; | |
278 extern GTY(()) int cgraph_max_pid; | |
279 extern bool cgraph_global_info_ready; | |
280 enum cgraph_state | |
281 { | |
282 /* Callgraph is being constructed. It is safe to add new functions. */ | |
283 CGRAPH_STATE_CONSTRUCTION, | |
284 /* Callgraph is built and IPA passes are being run. */ | |
285 CGRAPH_STATE_IPA, | |
286 /* Callgraph is built and all functions are transformed to SSA form. */ | |
287 CGRAPH_STATE_IPA_SSA, | |
288 /* Functions are now ordered and being passed to RTL expanders. */ | |
289 CGRAPH_STATE_EXPANSION, | |
290 /* All cgraph expansion is done. */ | |
291 CGRAPH_STATE_FINISHED | |
292 }; | |
293 extern enum cgraph_state cgraph_state; | |
294 extern bool cgraph_function_flags_ready; | |
295 extern GTY(()) struct cgraph_node *cgraph_nodes_queue; | |
296 extern GTY(()) struct cgraph_node *cgraph_new_nodes; | |
297 | |
298 extern GTY(()) struct cgraph_asm_node *cgraph_asm_nodes; | |
299 extern GTY(()) int cgraph_order; | |
300 | |
301 /* In cgraph.c */ | |
302 void dump_cgraph (FILE *); | |
303 void debug_cgraph (void); | |
304 void dump_cgraph_node (FILE *, struct cgraph_node *); | |
305 void debug_cgraph_node (struct cgraph_node *); | |
306 void cgraph_insert_node_to_hashtable (struct cgraph_node *node); | |
307 void cgraph_remove_edge (struct cgraph_edge *); | |
308 void cgraph_remove_node (struct cgraph_node *); | |
309 void cgraph_release_function_body (struct cgraph_node *); | |
310 void cgraph_node_remove_callees (struct cgraph_node *node); | |
311 struct cgraph_edge *cgraph_create_edge (struct cgraph_node *, | |
312 struct cgraph_node *, | |
313 gimple, gcov_type, int, int); | |
314 struct cgraph_node *cgraph_node (tree); | |
315 struct cgraph_node *cgraph_node_for_asm (tree asmname); | |
316 struct cgraph_edge *cgraph_edge (struct cgraph_node *, gimple); | |
317 void cgraph_set_call_stmt (struct cgraph_edge *, gimple); | |
318 void cgraph_update_edges_for_call_stmt (gimple, gimple); | |
319 struct cgraph_local_info *cgraph_local_info (tree); | |
320 struct cgraph_global_info *cgraph_global_info (tree); | |
321 struct cgraph_rtl_info *cgraph_rtl_info (tree); | |
322 const char * cgraph_node_name (struct cgraph_node *); | |
323 struct cgraph_edge * cgraph_clone_edge (struct cgraph_edge *, | |
324 struct cgraph_node *, | |
325 gimple, gcov_type, int, int, bool); | |
326 struct cgraph_node * cgraph_clone_node (struct cgraph_node *, gcov_type, int, | |
327 int, bool); | |
328 | |
329 void cgraph_redirect_edge_callee (struct cgraph_edge *, struct cgraph_node *); | |
330 | |
331 struct cgraph_asm_node *cgraph_add_asm_node (tree); | |
332 | |
333 bool cgraph_function_possibly_inlined_p (tree); | |
334 void cgraph_unnest_node (struct cgraph_node *); | |
335 | |
336 enum availability cgraph_function_body_availability (struct cgraph_node *); | |
337 bool cgraph_is_master_clone (struct cgraph_node *); | |
338 struct cgraph_node *cgraph_master_clone (struct cgraph_node *); | |
339 void cgraph_add_new_function (tree, bool); | |
340 | |
341 /* In cgraphunit.c */ | |
342 void cgraph_finalize_function (tree, bool); | |
343 void cgraph_mark_if_needed (tree); | |
344 void cgraph_finalize_compilation_unit (void); | |
345 void cgraph_optimize (void); | |
346 void cgraph_mark_needed_node (struct cgraph_node *); | |
347 void cgraph_mark_reachable_node (struct cgraph_node *); | |
348 bool cgraph_inline_p (struct cgraph_edge *, const char **reason); | |
349 bool cgraph_preserve_function_body_p (tree); | |
350 void verify_cgraph (void); | |
351 void verify_cgraph_node (struct cgraph_node *); | |
352 void cgraph_build_static_cdtor (char which, tree body, int priority); | |
353 void cgraph_reset_static_var_maps (void); | |
354 void init_cgraph (void); | |
355 struct cgraph_node *cgraph_function_versioning (struct cgraph_node *, | |
356 VEC(cgraph_edge_p,heap)*, | |
357 varray_type, | |
358 bitmap); | |
359 void cgraph_analyze_function (struct cgraph_node *); | |
360 struct cgraph_node *save_inline_function_body (struct cgraph_node *); | |
361 void record_references_in_initializer (tree); | |
362 bool cgraph_process_new_functions (void); | |
363 | |
364 typedef void (*cgraph_edge_hook)(struct cgraph_edge *, void *); | |
365 typedef void (*cgraph_node_hook)(struct cgraph_node *, void *); | |
366 typedef void (*cgraph_2edge_hook)(struct cgraph_edge *, struct cgraph_edge *, | |
367 void *); | |
368 typedef void (*cgraph_2node_hook)(struct cgraph_node *, struct cgraph_node *, | |
369 void *); | |
370 struct cgraph_edge_hook_list; | |
371 struct cgraph_node_hook_list; | |
372 struct cgraph_2edge_hook_list; | |
373 struct cgraph_2node_hook_list; | |
374 struct cgraph_edge_hook_list *cgraph_add_edge_removal_hook (cgraph_edge_hook, void *); | |
375 void cgraph_remove_edge_removal_hook (struct cgraph_edge_hook_list *); | |
376 struct cgraph_node_hook_list *cgraph_add_node_removal_hook (cgraph_node_hook, | |
377 void *); | |
378 void cgraph_remove_node_removal_hook (struct cgraph_node_hook_list *); | |
379 struct cgraph_node_hook_list *cgraph_add_function_insertion_hook (cgraph_node_hook, | |
380 void *); | |
381 void cgraph_remove_function_insertion_hook (struct cgraph_node_hook_list *); | |
382 void cgraph_call_function_insertion_hooks (struct cgraph_node *node); | |
383 struct cgraph_2edge_hook_list *cgraph_add_edge_duplication_hook (cgraph_2edge_hook, void *); | |
384 void cgraph_remove_edge_duplication_hook (struct cgraph_2edge_hook_list *); | |
385 struct cgraph_2node_hook_list *cgraph_add_node_duplication_hook (cgraph_2node_hook, void *); | |
386 void cgraph_remove_node_duplication_hook (struct cgraph_2node_hook_list *); | |
387 | |
388 /* In cgraphbuild.c */ | |
389 unsigned int rebuild_cgraph_edges (void); | |
390 int compute_call_stmt_bb_frequency (basic_block bb); | |
391 | |
392 /* In ipa.c */ | |
393 bool cgraph_remove_unreachable_nodes (bool, FILE *); | |
394 int cgraph_postorder (struct cgraph_node **); | |
395 | |
396 bool cgraph_maybe_hot_edge_p (struct cgraph_edge *e); | |
397 | |
398 /* In varpool.c */ | |
399 | |
400 extern GTY(()) struct varpool_node *varpool_nodes_queue; | |
401 extern GTY(()) struct varpool_node *varpool_nodes; | |
402 | |
403 struct varpool_node *varpool_node (tree); | |
404 struct varpool_node *varpool_node_for_asm (tree asmname); | |
405 void varpool_mark_needed_node (struct varpool_node *); | |
406 void dump_varpool (FILE *); | |
407 void dump_varpool_node (FILE *, struct varpool_node *); | |
408 | |
409 void varpool_finalize_decl (tree); | |
410 bool decide_is_variable_needed (struct varpool_node *, tree); | |
411 enum availability cgraph_variable_initializer_availability (struct varpool_node *); | |
412 | |
413 bool varpool_assemble_pending_decls (void); | |
414 bool varpool_assemble_decl (struct varpool_node *node); | |
415 bool varpool_analyze_pending_decls (void); | |
416 void varpool_remove_unreferenced_decls (void); | |
417 void varpool_empty_needed_queue (void); | |
418 | |
419 /* Walk all reachable static variables. */ | |
420 #define FOR_EACH_STATIC_VARIABLE(node) \ | |
421 for ((node) = varpool_nodes_queue; (node); (node) = (node)->next_needed) | |
422 | |
423 /* Return first reachable static variable with initializer. */ | |
424 static inline struct varpool_node * | |
425 varpool_first_static_initializer (void) | |
426 { | |
427 struct varpool_node *node; | |
428 for (node = varpool_nodes_queue; node; node = node->next_needed) | |
429 { | |
430 gcc_assert (TREE_CODE (node->decl) == VAR_DECL); | |
431 if (DECL_INITIAL (node->decl)) | |
432 return node; | |
433 } | |
434 return NULL; | |
435 } | |
436 | |
437 /* Return next reachable static variable with initializer after NODE. */ | |
438 static inline struct varpool_node * | |
439 varpool_next_static_initializer (struct varpool_node *node) | |
440 { | |
441 for (node = node->next_needed; node; node = node->next_needed) | |
442 { | |
443 gcc_assert (TREE_CODE (node->decl) == VAR_DECL); | |
444 if (DECL_INITIAL (node->decl)) | |
445 return node; | |
446 } | |
447 return NULL; | |
448 } | |
449 | |
450 /* Walk all static variables with initializer set. */ | |
451 #define FOR_EACH_STATIC_INITIALIZER(node) \ | |
452 for ((node) = varpool_first_static_initializer (); (node); \ | |
453 (node) = varpool_next_static_initializer (node)) | |
454 | |
455 /* In ipa-inline.c */ | |
456 void cgraph_clone_inlined_nodes (struct cgraph_edge *, bool, bool); | |
457 bool cgraph_default_inline_p (struct cgraph_node *, const char **); | |
458 unsigned int compute_inline_parameters (struct cgraph_node *); | |
459 | |
460 | |
461 /* Create a new static variable of type TYPE. */ | |
462 tree add_new_static_var (tree type); | |
463 | |
464 #endif /* GCC_CGRAPH_H */ |