]>
Commit | Line | Data |
---|---|---|
1c4a429a | 1 | /* Callgraph handling code. |
23a5b65a | 2 | Copyright (C) 2003-2014 Free Software Foundation, Inc. |
1c4a429a JH |
3 | Contributed by Jan Hubicka |
4 | ||
5 | This file is part of GCC. | |
6 | ||
7 | GCC is free software; you can redistribute it and/or modify it under | |
8 | the terms of the GNU General Public License as published by the Free | |
9dcd6f09 | 9 | Software Foundation; either version 3, or (at your option) any later |
1c4a429a JH |
10 | version. |
11 | ||
12 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
13 | WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
14 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
15 | for more details. | |
16 | ||
17 | You should have received a copy of the GNU General Public License | |
9dcd6f09 NC |
18 | along with GCC; see the file COPYING3. If not see |
19 | <http://www.gnu.org/licenses/>. */ | |
1c4a429a JH |
20 | |
21 | #ifndef GCC_CGRAPH_H | |
22 | #define GCC_CGRAPH_H | |
7a8cba34 | 23 | |
1f00098b JH |
24 | |
25 | /* Symbol table consists of functions and variables. | |
e70670cf | 26 | TODO: add labels and CONST_DECLs. */ |
1f00098b JH |
27 | enum symtab_type |
28 | { | |
960bfb69 | 29 | SYMTAB_SYMBOL, |
1f00098b JH |
30 | SYMTAB_FUNCTION, |
31 | SYMTAB_VARIABLE | |
32 | }; | |
33 | ||
f961457f JH |
34 | /* Section names are stored as reference counted strings in GGC safe hashtable |
35 | (to make them survive through PCH). */ | |
36 | ||
2a22f99c | 37 | struct GTY((for_user)) section_hash_entry_d |
f961457f JH |
38 | { |
39 | int ref_count; | |
40 | char *name; /* As long as this datastructure stays in GGC, we can not put | |
41 | string at the tail of structure of GGC dies in horrible | |
42 | way */ | |
43 | }; | |
44 | ||
45 | typedef struct section_hash_entry_d section_hash_entry; | |
46 | ||
2a22f99c TS |
47 | struct section_name_hasher : ggc_hasher<section_hash_entry *> |
48 | { | |
49 | typedef const char *compare_type; | |
50 | ||
51 | static hashval_t hash (section_hash_entry *); | |
52 | static bool equal (section_hash_entry *, const char *); | |
53 | }; | |
54 | ||
d52f5295 ML |
55 | enum availability |
56 | { | |
57 | /* Not yet set by cgraph_function_body_availability. */ | |
58 | AVAIL_UNSET, | |
59 | /* Function body/variable initializer is unknown. */ | |
60 | AVAIL_NOT_AVAILABLE, | |
61 | /* Function body/variable initializer is known but might be replaced | |
62 | by a different one from other compilation unit and thus needs to | |
63 | be dealt with a care. Like AVAIL_NOT_AVAILABLE it can have | |
64 | arbitrary side effects on escaping variables and functions, while | |
65 | like AVAILABLE it might access static variables. */ | |
66 | AVAIL_INTERPOSABLE, | |
67 | /* Function body/variable initializer is known and will be used in final | |
68 | program. */ | |
69 | AVAIL_AVAILABLE, | |
70 | /* Function body/variable initializer is known and all it's uses are | |
71 | explicitly visible within current unit (ie it's address is never taken and | |
72 | it is not exported to other units). Currently used only for functions. */ | |
73 | AVAIL_LOCAL | |
74 | }; | |
75 | ||
76 | /* Classification of symbols WRT partitioning. */ | |
77 | enum symbol_partitioning_class | |
78 | { | |
79 | /* External declarations are ignored by partitioning algorithms and they are | |
80 | added into the boundary later via compute_ltrans_boundary. */ | |
81 | SYMBOL_EXTERNAL, | |
82 | /* Partitioned symbols are pur into one of partitions. */ | |
83 | SYMBOL_PARTITION, | |
84 | /* Duplicated symbols (such as comdat or constant pool references) are | |
85 | copied into every node needing them via add_symbol_to_partition. */ | |
86 | SYMBOL_DUPLICATE | |
87 | }; | |
88 | ||
1f00098b JH |
89 | /* Base of all entries in the symbol table. |
90 | The symtab_node is inherited by cgraph and varpol nodes. */ | |
a3bfa8b8 DM |
91 | class GTY((desc ("%h.type"), tag ("SYMTAB_SYMBOL"), |
92 | chain_next ("%h.next"), chain_prev ("%h.previous"))) | |
5e20cdc9 | 93 | symtab_node |
1f00098b | 94 | { |
a3bfa8b8 | 95 | public: |
fec39fa6 TS |
96 | /* Return name. */ |
97 | const char *name () const; | |
98 | ||
99 | /* Return asm name. */ | |
100 | const char * asm_name () const; | |
101 | ||
d52f5295 ML |
102 | /* Add node into symbol table. This function is not used directly, but via |
103 | cgraph/varpool node creation routines. */ | |
104 | void register_symbol (void); | |
105 | ||
106 | /* Remove symbol from symbol table. */ | |
107 | void remove (void); | |
108 | ||
109 | /* Dump symtab node to F. */ | |
110 | void dump (FILE *f); | |
111 | ||
112 | /* Dump symtab node to stderr. */ | |
113 | void DEBUG_FUNCTION debug (void); | |
114 | ||
115 | /* Verify consistency of node. */ | |
116 | void DEBUG_FUNCTION verify (void); | |
117 | ||
118 | /* Return ipa reference from this symtab_node to | |
119 | REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type | |
120 | of the use and STMT the statement (if it exists). */ | |
3dafb85c ML |
121 | ipa_ref *create_reference (symtab_node *referred_node, |
122 | enum ipa_ref_use use_type); | |
d52f5295 ML |
123 | |
124 | /* Return ipa reference from this symtab_node to | |
125 | REFERED_NODE or REFERED_VARPOOL_NODE. USE_TYPE specify type | |
126 | of the use and STMT the statement (if it exists). */ | |
3dafb85c ML |
127 | ipa_ref *create_reference (symtab_node *referred_node, |
128 | enum ipa_ref_use use_type, gimple stmt); | |
d52f5295 ML |
129 | |
130 | /* If VAL is a reference to a function or a variable, add a reference from | |
131 | this symtab_node to the corresponding symbol table node. USE_TYPE specify | |
132 | type of the use and STMT the statement (if it exists). Return the new | |
133 | reference or NULL if none was created. */ | |
3dafb85c ML |
134 | ipa_ref *maybe_create_reference (tree val, enum ipa_ref_use use_type, |
135 | gimple stmt); | |
d52f5295 ML |
136 | |
137 | /* Clone all references from symtab NODE to this symtab_node. */ | |
138 | void clone_references (symtab_node *node); | |
139 | ||
140 | /* Remove all stmt references in non-speculative references. | |
141 | Those are not maintained during inlining & clonning. | |
142 | The exception are speculative references that are updated along | |
143 | with callgraph edges associated with them. */ | |
144 | void clone_referring (symtab_node *node); | |
145 | ||
146 | /* Clone reference REF to this symtab_node and set its stmt to STMT. */ | |
3dafb85c | 147 | ipa_ref *clone_reference (ipa_ref *ref, gimple stmt); |
d52f5295 ML |
148 | |
149 | /* Find the structure describing a reference to REFERRED_NODE | |
150 | and associated with statement STMT. */ | |
3dafb85c ML |
151 | ipa_ref *find_reference (symtab_node *referred_node, gimple stmt, |
152 | unsigned int lto_stmt_uid); | |
d52f5295 ML |
153 | |
154 | /* Remove all references that are associated with statement STMT. */ | |
155 | void remove_stmt_references (gimple stmt); | |
156 | ||
157 | /* Remove all stmt references in non-speculative references. | |
158 | Those are not maintained during inlining & clonning. | |
159 | The exception are speculative references that are updated along | |
160 | with callgraph edges associated with them. */ | |
161 | void clear_stmts_in_references (void); | |
162 | ||
163 | /* Remove all references in ref list. */ | |
164 | void remove_all_references (void); | |
165 | ||
166 | /* Remove all referring items in ref list. */ | |
167 | void remove_all_referring (void); | |
168 | ||
169 | /* Dump references in ref list to FILE. */ | |
170 | void dump_references (FILE *file); | |
171 | ||
172 | /* Dump referring in list to FILE. */ | |
173 | void dump_referring (FILE *); | |
174 | ||
b84d4347 ML |
175 | /* Get number of references for this node. */ |
176 | inline unsigned num_references (void) | |
177 | { | |
178 | return ref_list.references ? ref_list.references->length () : 0; | |
179 | } | |
180 | ||
d52f5295 | 181 | /* Iterates I-th reference in the list, REF is also set. */ |
3dafb85c | 182 | ipa_ref *iterate_reference (unsigned i, ipa_ref *&ref); |
d52f5295 ML |
183 | |
184 | /* Iterates I-th referring item in the list, REF is also set. */ | |
3dafb85c | 185 | ipa_ref *iterate_referring (unsigned i, ipa_ref *&ref); |
d52f5295 ML |
186 | |
187 | /* Iterates I-th referring alias item in the list, REF is also set. */ | |
3dafb85c | 188 | ipa_ref *iterate_direct_aliases (unsigned i, ipa_ref *&ref); |
d52f5295 ML |
189 | |
190 | /* Return true if symtab node and TARGET represents | |
191 | semantically equivalent symbols. */ | |
192 | bool semantically_equivalent_p (symtab_node *target); | |
193 | ||
194 | /* Classify symbol symtab node for partitioning. */ | |
195 | enum symbol_partitioning_class get_partitioning_class (void); | |
196 | ||
197 | /* Return comdat group. */ | |
198 | tree get_comdat_group () | |
199 | { | |
200 | return x_comdat_group; | |
201 | } | |
202 | ||
203 | /* Return comdat group as identifier_node. */ | |
204 | tree get_comdat_group_id () | |
205 | { | |
206 | if (x_comdat_group && TREE_CODE (x_comdat_group) != IDENTIFIER_NODE) | |
207 | x_comdat_group = DECL_ASSEMBLER_NAME (x_comdat_group); | |
208 | return x_comdat_group; | |
209 | } | |
210 | ||
211 | /* Set comdat group. */ | |
212 | void set_comdat_group (tree group) | |
213 | { | |
214 | gcc_checking_assert (!group || TREE_CODE (group) == IDENTIFIER_NODE | |
215 | || DECL_P (group)); | |
216 | x_comdat_group = group; | |
217 | } | |
218 | ||
219 | /* Return section as string. */ | |
220 | const char * get_section () | |
221 | { | |
222 | if (!x_section) | |
223 | return NULL; | |
224 | return x_section->name; | |
225 | } | |
226 | ||
227 | /* Remove node from same comdat group. */ | |
228 | void remove_from_same_comdat_group (void); | |
229 | ||
230 | /* Add this symtab_node to the same comdat group that OLD is in. */ | |
231 | void add_to_same_comdat_group (symtab_node *old_node); | |
232 | ||
233 | /* Dissolve the same_comdat_group list in which NODE resides. */ | |
234 | void dissolve_same_comdat_group_list (void); | |
235 | ||
236 | /* Return true when symtab_node is known to be used from other (non-LTO) | |
237 | object file. Known only when doing LTO via linker plugin. */ | |
238 | bool used_from_object_file_p (void); | |
239 | ||
240 | /* Walk the alias chain to return the symbol NODE is alias of. | |
241 | If NODE is not an alias, return NODE. | |
242 | When AVAILABILITY is non-NULL, get minimal availability in the chain. */ | |
243 | symtab_node *ultimate_alias_target (enum availability *avail = NULL); | |
244 | ||
245 | /* Return next reachable static symbol with initializer after NODE. */ | |
246 | inline symtab_node *next_defined_symbol (void); | |
247 | ||
248 | /* Add reference recording that symtab node is alias of TARGET. | |
249 | The function can fail in the case of aliasing cycles; in this case | |
250 | it returns false. */ | |
251 | bool resolve_alias (symtab_node *target); | |
252 | ||
253 | /* C++ FE sometimes change linkage flags after producing same | |
254 | body aliases. */ | |
255 | void fixup_same_cpp_alias_visibility (symtab_node *target); | |
256 | ||
257 | /* Call calback on symtab node and aliases associated to this node. | |
258 | When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are | |
259 | skipped. */ | |
260 | bool call_for_symbol_and_aliases (bool (*callback) (symtab_node *, void *), | |
261 | void *data, | |
262 | bool include_overwrite); | |
263 | ||
264 | /* If node can not be interposable by static or dynamic linker to point to | |
265 | different definition, return this symbol. Otherwise look for alias with | |
266 | such property and if none exists, introduce new one. */ | |
267 | symtab_node *noninterposable_alias (void); | |
268 | ||
269 | /* Return node that alias is aliasing. */ | |
270 | inline symtab_node *get_alias_target (void); | |
271 | ||
272 | /* Set section for symbol and its aliases. */ | |
273 | void set_section (const char *section); | |
274 | ||
275 | /* Set section, do not recurse into aliases. | |
276 | When one wants to change section of symbol and its aliases, | |
277 | use set_section. */ | |
278 | void set_section_for_node (const char *section); | |
279 | ||
280 | /* Set initialization priority to PRIORITY. */ | |
281 | void set_init_priority (priority_type priority); | |
282 | ||
283 | /* Return the initialization priority. */ | |
284 | priority_type get_init_priority (); | |
285 | ||
286 | /* Return availability of NODE. */ | |
287 | enum availability get_availability (void); | |
288 | ||
289 | /* Make DECL local. */ | |
290 | void make_decl_local (void); | |
291 | ||
292 | /* Return true if list contains an alias. */ | |
293 | bool has_aliases_p (void); | |
294 | ||
295 | /* Return true when the symbol is real symbol, i.e. it is not inline clone | |
296 | or abstract function kept for debug info purposes only. */ | |
297 | bool real_symbol_p (void); | |
298 | ||
3dafb85c ML |
299 | /* Determine if symbol declaration is needed. That is, visible to something |
300 | either outside this translation unit, something magic in the system | |
301 | configury. This function is used just during symbol creation. */ | |
302 | bool needed_p (void); | |
303 | ||
304 | /* Return true when there are references to the node. */ | |
305 | bool referred_to_p (void); | |
306 | ||
d52f5295 ML |
307 | /* Return true if NODE can be discarded by linker from the binary. */ |
308 | inline bool | |
309 | can_be_discarded_p (void) | |
310 | { | |
311 | return (DECL_EXTERNAL (decl) | |
312 | || (get_comdat_group () | |
313 | && resolution != LDPR_PREVAILING_DEF | |
314 | && resolution != LDPR_PREVAILING_DEF_IRONLY | |
315 | && resolution != LDPR_PREVAILING_DEF_IRONLY_EXP)); | |
316 | } | |
317 | ||
318 | /* Return true if NODE is local to a particular COMDAT group, and must not | |
319 | be named from outside the COMDAT. This is used for C++ decloned | |
320 | constructors. */ | |
321 | inline bool comdat_local_p (void) | |
322 | { | |
323 | return (same_comdat_group && !TREE_PUBLIC (decl)); | |
324 | } | |
325 | ||
326 | /* Return true if ONE and TWO are part of the same COMDAT group. */ | |
327 | inline bool in_same_comdat_group_p (symtab_node *target); | |
328 | ||
329 | /* Return true when there is a reference to node and it is not vtable. */ | |
330 | bool address_taken_from_non_vtable_p (void); | |
331 | ||
332 | /* Return true if symbol is known to be nonzero. */ | |
333 | bool nonzero_address (); | |
334 | ||
335 | /* Return symbol table node associated with DECL, if any, | |
336 | and NULL otherwise. */ | |
337 | static inline symtab_node *get (const_tree decl) | |
338 | { | |
339 | #ifdef ENABLE_CHECKING | |
340 | /* Check that we are called for sane type of object - functions | |
341 | and static or external variables. */ | |
342 | gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL | |
343 | || (TREE_CODE (decl) == VAR_DECL | |
344 | && (TREE_STATIC (decl) || DECL_EXTERNAL (decl) | |
345 | || in_lto_p))); | |
346 | /* Check that the mapping is sane - perhaps this check can go away, | |
347 | but at the moment frontends tends to corrupt the mapping by calling | |
348 | memcpy/memset on the tree nodes. */ | |
349 | gcc_checking_assert (!decl->decl_with_vis.symtab_node | |
350 | || decl->decl_with_vis.symtab_node->decl == decl); | |
351 | #endif | |
352 | return decl->decl_with_vis.symtab_node; | |
353 | } | |
354 | ||
f7217cde JH |
355 | /* Try to find a symtab node for declaration DECL and if it does not |
356 | exist or if it corresponds to an inline clone, create a new one. */ | |
357 | static inline symtab_node * get_create (tree node); | |
358 | ||
3dafb85c ML |
359 | /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME. |
360 | Return NULL if there's no such node. */ | |
361 | static symtab_node *get_for_asmname (const_tree asmname); | |
362 | ||
d52f5295 ML |
363 | /* Dump symbol table to F. */ |
364 | static void dump_table (FILE *); | |
365 | ||
366 | /* Dump symbol table to stderr. */ | |
367 | static inline DEBUG_FUNCTION void debug_symtab (void) | |
368 | { | |
369 | dump_table (stderr); | |
370 | } | |
371 | ||
372 | /* Verify symbol table for internal consistency. */ | |
373 | static DEBUG_FUNCTION void verify_symtab_nodes (void); | |
374 | ||
375 | /* Return true when NODE is known to be used from other (non-LTO) | |
376 | object file. Known only when doing LTO via linker plugin. */ | |
377 | static bool used_from_object_file_p_worker (symtab_node *node); | |
378 | ||
1f00098b | 379 | /* Type of the symbol. */ |
b8dbdb12 RG |
380 | ENUM_BITFIELD (symtab_type) type : 8; |
381 | ||
382 | /* The symbols resolution. */ | |
383 | ENUM_BITFIELD (ld_plugin_symbol_resolution) resolution : 8; | |
384 | ||
e70670cf JH |
385 | /*** Flags representing the symbol type. ***/ |
386 | ||
387 | /* True when symbol corresponds to a definition in current unit. | |
3dafb85c | 388 | set via finalize_function or finalize_decl */ |
e70670cf | 389 | unsigned definition : 1; |
9041d2e6 ML |
390 | /* True when symbol is an alias. |
391 | Set by ssemble_alias. */ | |
e70670cf | 392 | unsigned alias : 1; |
08346abd JH |
393 | /* True when alias is a weakref. */ |
394 | unsigned weakref : 1; | |
40a7fe1e | 395 | /* C++ frontend produce same body aliases and extra name aliases for |
688010ba | 396 | virtual functions and vtables that are obviously equivalent. |
40a7fe1e JH |
397 | Those aliases are bit special, especially because C++ frontend |
398 | visibility code is so ugly it can not get them right at first time | |
399 | and their visibility needs to be copied from their "masters" at | |
400 | the end of parsing. */ | |
401 | unsigned cpp_implicit_alias : 1; | |
e70670cf JH |
402 | /* Set once the definition was analyzed. The list of references and |
403 | other properties are built during analysis. */ | |
404 | unsigned analyzed : 1; | |
6de88c6a JH |
405 | /* Set for write-only variables. */ |
406 | unsigned writeonly : 1; | |
f7217cde JH |
407 | /* Visibility of symbol was used for further optimization; do not |
408 | permit further changes. */ | |
409 | unsigned refuse_visibility_changes : 1; | |
e70670cf JH |
410 | |
411 | /*** Visibility and linkage flags. ***/ | |
412 | ||
b8dbdb12 RG |
413 | /* Set when function is visible by other units. */ |
414 | unsigned externally_visible : 1; | |
7861b648 AK |
415 | /* Don't reorder to other symbols having this set. */ |
416 | unsigned no_reorder : 1; | |
4bcfd75c | 417 | /* The symbol will be assumed to be used in an invisible way (like |
edb983b2 | 418 | by an toplevel asm statement). */ |
b8dbdb12 | 419 | unsigned force_output : 1; |
edb983b2 JH |
420 | /* Like FORCE_OUTPUT, but in the case it is ABI requiring the symbol to be |
421 | exported. Unlike FORCE_OUTPUT this flag gets cleared to symbols promoted | |
422 | to static and it does not inhibit optimization. */ | |
423 | unsigned forced_by_abi : 1; | |
702d8703 JH |
424 | /* True when the name is known to be unique and thus it does not need mangling. */ |
425 | unsigned unique_name : 1; | |
e257a17c JH |
426 | /* Specify whether the section was set by user or by |
427 | compiler via -ffunction-sections. */ | |
428 | unsigned implicit_section : 1; | |
3d8d0043 MJ |
429 | /* True when body and other characteristics have been removed by |
430 | symtab_remove_unreachable_nodes. */ | |
431 | unsigned body_removed : 1; | |
b8dbdb12 | 432 | |
e70670cf JH |
433 | /*** WHOPR Partitioning flags. |
434 | These flags are used at ltrans stage when only part of the callgraph is | |
435 | available. ***/ | |
b8dbdb12 | 436 | |
e70670cf JH |
437 | /* Set when variable is used from other LTRANS partition. */ |
438 | unsigned used_from_other_partition : 1; | |
9041d2e6 | 439 | /* Set when function is available in the other LTRANS partition. |
e70670cf JH |
440 | During WPA output it is used to mark nodes that are present in |
441 | multiple partitions. */ | |
442 | unsigned in_other_partition : 1; | |
b8dbdb12 | 443 | |
b8dbdb12 | 444 | |
e70670cf JH |
445 | |
446 | /*** other flags. ***/ | |
447 | ||
448 | /* Set when symbol has address taken. */ | |
449 | unsigned address_taken : 1; | |
569b1784 JH |
450 | /* Set when init priority is set. */ |
451 | unsigned in_init_priority_hash : 1; | |
e70670cf | 452 | |
1f6be682 IV |
453 | /* Set when symbol needs to be streamed into LTO bytecode for LTO, or in case |
454 | of offloading, for separate compilation for a different target. */ | |
455 | unsigned need_lto_streaming : 1; | |
456 | ||
457 | /* Set when symbol can be streamed into bytecode for offloading. */ | |
458 | unsigned offloadable : 1; | |
459 | ||
e70670cf JH |
460 | |
461 | /* Ordering of all symtab entries. */ | |
462 | int order; | |
463 | ||
464 | /* Declaration representing the symbol. */ | |
465 | tree decl; | |
960bfb69 | 466 | |
2aae7680 | 467 | /* Linked list of symbol table entries starting with symtab_nodes. */ |
5e20cdc9 DM |
468 | symtab_node *next; |
469 | symtab_node *previous; | |
e70670cf | 470 | |
1ab24192 | 471 | /* Linked list of symbols with the same asm name. There may be multiple |
e70670cf JH |
472 | entries for single symbol name during LTO, because symbols are renamed |
473 | only after partitioning. | |
474 | ||
475 | Because inline clones are kept in the assembler name has, they also produce | |
476 | duplicate entries. | |
477 | ||
478 | There are also several long standing bugs where frontends and builtin | |
479 | code produce duplicated decls. */ | |
5e20cdc9 DM |
480 | symtab_node *next_sharing_asm_name; |
481 | symtab_node *previous_sharing_asm_name; | |
2aae7680 | 482 | |
d52f5295 ML |
483 | /* Circular list of nodes in the same comdat group if non-NULL. */ |
484 | symtab_node *same_comdat_group; | |
e55637b7 | 485 | |
e70670cf | 486 | /* Vectors of referring and referenced entities. */ |
3dafb85c | 487 | ipa_ref_list ref_list; |
e70670cf | 488 | |
40a7fe1e JH |
489 | /* Alias target. May be either DECL pointer or ASSEMBLER_NAME pointer |
490 | depending to what was known to frontend on the creation time. | |
491 | Once alias is resolved, this pointer become NULL. */ | |
492 | tree alias_target; | |
493 | ||
e70670cf JH |
494 | /* File stream where this node is being written to. */ |
495 | struct lto_file_decl_data * lto_file_data; | |
496 | ||
960bfb69 | 497 | PTR GTY ((skip)) aux; |
aede2c10 JH |
498 | |
499 | /* Comdat group the symbol is in. Can be private if GGC allowed that. */ | |
f961457f | 500 | tree x_comdat_group; |
24d047a3 JH |
501 | |
502 | /* Section name. Again can be private, if allowed. */ | |
f961457f | 503 | section_hash_entry *x_section; |
e257a17c | 504 | |
d52f5295 ML |
505 | protected: |
506 | /* Dump base fields of symtab nodes to F. Not to be used directly. */ | |
507 | void dump_base (FILE *); | |
569b1784 | 508 | |
d52f5295 ML |
509 | /* Verify common part of symtab node. */ |
510 | bool DEBUG_FUNCTION verify_base (void); | |
89330618 | 511 | |
d52f5295 ML |
512 | /* Remove node from symbol table. This function is not used directly, but via |
513 | cgraph/varpool node removal routines. */ | |
514 | void unregister (void); | |
515 | ||
516 | /* Return the initialization and finalization priority information for | |
517 | DECL. If there is no previous priority information, a freshly | |
518 | allocated structure is returned. */ | |
519 | struct symbol_priority_map *priority_info (void); | |
520 | ||
521 | private: | |
522 | /* Worker for set_section. */ | |
523 | static bool set_section (symtab_node *n, void *s); | |
524 | ||
525 | /* Worker for symtab_resolve_alias. */ | |
526 | static bool set_implicit_section (symtab_node *n, void *); | |
527 | ||
528 | /* Worker searching noninterposable alias. */ | |
529 | static bool noninterposable_alias (symtab_node *node, void *data); | |
1f00098b | 530 | }; |
1c4a429a | 531 | |
e55637b7 ML |
532 | /* Walk all aliases for NODE. */ |
533 | #define FOR_EACH_ALIAS(node, alias) \ | |
d52f5295 | 534 | for (unsigned x_i = 0; node->iterate_direct_aliases (x_i, alias); x_i++) |
6b02a499 | 535 | |
d7f09764 DN |
536 | /* This is the information that is put into the cgraph local structure |
537 | to recover a function. */ | |
538 | struct lto_file_decl_data; | |
539 | ||
8a4a83ed | 540 | extern const char * const cgraph_availability_names[]; |
430c6ceb | 541 | extern const char * const ld_plugin_symbol_resolution_names[]; |
714c800f | 542 | extern const char * const tls_model_names[]; |
8a4a83ed | 543 | |
6744a6ab JH |
544 | /* Information about thunk, used only for same body aliases. */ |
545 | ||
546 | struct GTY(()) cgraph_thunk_info { | |
547 | /* Information about the thunk. */ | |
548 | HOST_WIDE_INT fixed_offset; | |
549 | HOST_WIDE_INT virtual_value; | |
550 | tree alias; | |
551 | bool this_adjusting; | |
552 | bool virtual_offset_p; | |
d5e254e1 | 553 | bool add_pointer_bounds_args; |
6744a6ab JH |
554 | /* Set to true when alias node is thunk. */ |
555 | bool thunk_p; | |
556 | }; | |
557 | ||
dafc5b82 | 558 | /* Information about the function collected locally. |
25c84396 | 559 | Available after function is analyzed. */ |
dafc5b82 | 560 | |
d1b38208 | 561 | struct GTY(()) cgraph_local_info { |
e0bb17a8 | 562 | /* Set when function function is visible in current compilation unit only |
e2209b03 | 563 | and its address is never taken. */ |
b4e19405 | 564 | unsigned local : 1; |
6674a6ce | 565 | |
124f1be6 MJ |
566 | /* False when there is something makes versioning impossible. */ |
567 | unsigned versionable : 1; | |
568 | ||
61e03ffc JH |
569 | /* False when function calling convention and signature can not be changed. |
570 | This is the case when __builtin_apply_args is used. */ | |
571 | unsigned can_change_signature : 1; | |
572 | ||
95c755e9 JH |
573 | /* True when the function has been originally extern inline, but it is |
574 | redefined now. */ | |
b4e19405 | 575 | unsigned redefined_extern_inline : 1; |
0a35513e AH |
576 | |
577 | /* True if the function may enter serial irrevocable mode. */ | |
578 | unsigned tm_may_enter_irr : 1; | |
dafc5b82 JH |
579 | }; |
580 | ||
581 | /* Information about the function that needs to be computed globally | |
726a989a | 582 | once compilation is finished. Available only with -funit-at-a-time. */ |
dafc5b82 | 583 | |
d1b38208 | 584 | struct GTY(()) cgraph_global_info { |
726a989a RB |
585 | /* For inline clones this points to the function they will be |
586 | inlined into. */ | |
d52f5295 | 587 | cgraph_node *inlined_to; |
dafc5b82 JH |
588 | }; |
589 | ||
b255a036 JH |
590 | /* Information about the function that is propagated by the RTL backend. |
591 | Available only for functions that has been already assembled. */ | |
592 | ||
d1b38208 | 593 | struct GTY(()) cgraph_rtl_info { |
17b29c0a | 594 | unsigned int preferred_incoming_stack_boundary; |
27c07cc5 RO |
595 | |
596 | /* Call unsaved hard registers really used by the corresponding | |
597 | function (including ones used by functions called by the | |
598 | function). */ | |
599 | HARD_REG_SET function_used_regs; | |
600 | /* Set if function_used_regs is valid. */ | |
601 | unsigned function_used_regs_valid: 1; | |
b255a036 JH |
602 | }; |
603 | ||
9187e02d JH |
604 | /* Represent which DECL tree (or reference to such tree) |
605 | will be replaced by another tree while versioning. */ | |
606 | struct GTY(()) ipa_replace_map | |
607 | { | |
608 | /* The tree that will be replaced. */ | |
609 | tree old_tree; | |
610 | /* The new (replacing) tree. */ | |
611 | tree new_tree; | |
922f15c2 JH |
612 | /* Parameter number to replace, when old_tree is NULL. */ |
613 | int parm_num; | |
9187e02d JH |
614 | /* True when a substitution should be done, false otherwise. */ |
615 | bool replace_p; | |
616 | /* True when we replace a reference to old_tree. */ | |
617 | bool ref_p; | |
618 | }; | |
9187e02d JH |
619 | |
620 | struct GTY(()) cgraph_clone_info | |
621 | { | |
d52f5295 | 622 | vec<ipa_replace_map *, va_gc> *tree_map; |
9187e02d | 623 | bitmap args_to_skip; |
08ad1d6d | 624 | bitmap combined_args_to_skip; |
9187e02d JH |
625 | }; |
626 | ||
0136f8f0 AH |
627 | enum cgraph_simd_clone_arg_type |
628 | { | |
629 | SIMD_CLONE_ARG_TYPE_VECTOR, | |
630 | SIMD_CLONE_ARG_TYPE_UNIFORM, | |
631 | SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP, | |
632 | SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP, | |
633 | SIMD_CLONE_ARG_TYPE_MASK | |
634 | }; | |
635 | ||
636 | /* Function arguments in the original function of a SIMD clone. | |
637 | Supplementary data for `struct simd_clone'. */ | |
638 | ||
639 | struct GTY(()) cgraph_simd_clone_arg { | |
640 | /* Original function argument as it originally existed in | |
641 | DECL_ARGUMENTS. */ | |
642 | tree orig_arg; | |
643 | ||
644 | /* orig_arg's function (or for extern functions type from | |
645 | TYPE_ARG_TYPES). */ | |
646 | tree orig_type; | |
647 | ||
648 | /* If argument is a vector, this holds the vector version of | |
649 | orig_arg that after adjusting the argument types will live in | |
650 | DECL_ARGUMENTS. Otherwise, this is NULL. | |
651 | ||
652 | This basically holds: | |
653 | vector(simdlen) __typeof__(orig_arg) new_arg. */ | |
654 | tree vector_arg; | |
655 | ||
656 | /* vector_arg's type (or for extern functions new vector type. */ | |
657 | tree vector_type; | |
658 | ||
659 | /* If argument is a vector, this holds the array where the simd | |
660 | argument is held while executing the simd clone function. This | |
661 | is a local variable in the cloned function. Its content is | |
662 | copied from vector_arg upon entry to the clone. | |
663 | ||
664 | This basically holds: | |
665 | __typeof__(orig_arg) simd_array[simdlen]. */ | |
666 | tree simd_array; | |
667 | ||
668 | /* A SIMD clone's argument can be either linear (constant or | |
669 | variable), uniform, or vector. */ | |
670 | enum cgraph_simd_clone_arg_type arg_type; | |
671 | ||
672 | /* For arg_type SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP this is | |
673 | the constant linear step, if arg_type is | |
674 | SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP, this is index of | |
675 | the uniform argument holding the step, otherwise 0. */ | |
676 | HOST_WIDE_INT linear_step; | |
677 | ||
678 | /* Variable alignment if available, otherwise 0. */ | |
679 | unsigned int alignment; | |
680 | }; | |
681 | ||
682 | /* Specific data for a SIMD function clone. */ | |
683 | ||
684 | struct GTY(()) cgraph_simd_clone { | |
685 | /* Number of words in the SIMD lane associated with this clone. */ | |
686 | unsigned int simdlen; | |
687 | ||
688 | /* Number of annotated function arguments in `args'. This is | |
689 | usually the number of named arguments in FNDECL. */ | |
690 | unsigned int nargs; | |
691 | ||
692 | /* Max hardware vector size in bits for integral vectors. */ | |
693 | unsigned int vecsize_int; | |
694 | ||
695 | /* Max hardware vector size in bits for floating point vectors. */ | |
696 | unsigned int vecsize_float; | |
697 | ||
698 | /* The mangling character for a given vector size. This is is used | |
699 | to determine the ISA mangling bit as specified in the Intel | |
700 | Vector ABI. */ | |
701 | unsigned char vecsize_mangle; | |
702 | ||
703 | /* True if this is the masked, in-branch version of the clone, | |
704 | otherwise false. */ | |
705 | unsigned int inbranch : 1; | |
706 | ||
707 | /* True if this is a Cilk Plus variant. */ | |
708 | unsigned int cilk_elemental : 1; | |
709 | ||
710 | /* Doubly linked list of SIMD clones. */ | |
d52f5295 | 711 | cgraph_node *prev_clone, *next_clone; |
0136f8f0 AH |
712 | |
713 | /* Original cgraph node the SIMD clones were created for. */ | |
d52f5295 | 714 | cgraph_node *origin; |
0136f8f0 AH |
715 | |
716 | /* Annotated function arguments for the original function. */ | |
3dafb85c | 717 | cgraph_simd_clone_arg GTY((length ("%h.nargs"))) args[1]; |
0136f8f0 AH |
718 | }; |
719 | ||
d52f5295 | 720 | /* Function Multiversioning info. */ |
2a22f99c | 721 | struct GTY((for_user)) cgraph_function_version_info { |
d52f5295 ML |
722 | /* The cgraph_node for which the function version info is stored. */ |
723 | cgraph_node *this_node; | |
724 | /* Chains all the semantically identical function versions. The | |
725 | first function in this chain is the version_info node of the | |
726 | default function. */ | |
3dafb85c | 727 | cgraph_function_version_info *prev; |
d52f5295 ML |
728 | /* If this version node corresponds to a dispatcher for function |
729 | versions, this points to the version info node of the default | |
730 | function, the first node in the chain. */ | |
3dafb85c | 731 | cgraph_function_version_info *next; |
d52f5295 ML |
732 | /* If this node corresponds to a function version, this points |
733 | to the dispatcher function decl, which is the function that must | |
734 | be called to execute the right function version at run-time. | |
735 | ||
736 | If this cgraph node is a dispatcher (if dispatcher_function is | |
737 | true, in the cgraph_node struct) for function versions, this | |
738 | points to resolver function, which holds the function body of the | |
739 | dispatcher. The dispatcher decl is an alias to the resolver | |
740 | function decl. */ | |
741 | tree dispatcher_resolver; | |
742 | }; | |
743 | ||
744 | #define DEFCIFCODE(code, type, string) CIF_ ## code, | |
745 | /* Reasons for inlining failures. */ | |
746 | ||
747 | enum cgraph_inline_failed_t { | |
748 | #include "cif-code.def" | |
749 | CIF_N_REASONS | |
750 | }; | |
751 | ||
752 | enum cgraph_inline_failed_type_t | |
753 | { | |
754 | CIF_FINAL_NORMAL = 0, | |
755 | CIF_FINAL_ERROR | |
756 | }; | |
757 | ||
758 | struct cgraph_edge; | |
5fefcf92 | 759 | |
2a22f99c TS |
760 | struct cgraph_edge_hasher : ggc_hasher<cgraph_edge *> |
761 | { | |
762 | typedef gimple compare_type; | |
763 | ||
764 | static hashval_t hash (cgraph_edge *); | |
765 | static bool equal (cgraph_edge *, gimple); | |
766 | }; | |
767 | ||
ba228239 | 768 | /* The cgraph data structure. |
e0bb17a8 | 769 | Each function decl has assigned cgraph_node listing callees and callers. */ |
1c4a429a | 770 | |
5e20cdc9 | 771 | struct GTY((tag ("SYMTAB_FUNCTION"))) cgraph_node : public symtab_node { |
a3bfa8b8 | 772 | public: |
d52f5295 ML |
773 | /* Remove the node from cgraph and all inline clones inlined into it. |
774 | Skip however removal of FORBIDDEN_NODE and return true if it needs to be | |
775 | removed. This allows to call the function from outer loop walking clone | |
776 | tree. */ | |
777 | bool remove_symbol_and_inline_clones (cgraph_node *forbidden_node = NULL); | |
778 | ||
779 | /* Record all references from cgraph_node that are taken | |
780 | in statement STMT. */ | |
781 | void record_stmt_references (gimple stmt); | |
782 | ||
783 | /* Like cgraph_set_call_stmt but walk the clone tree and update all | |
784 | clones sharing the same function body. | |
785 | When WHOLE_SPECULATIVE_EDGES is true, all three components of | |
786 | speculative edge gets updated. Otherwise we update only direct | |
787 | call. */ | |
788 | void set_call_stmt_including_clones (gimple old_stmt, gimple new_stmt, | |
789 | bool update_speculative = true); | |
790 | ||
791 | /* Walk the alias chain to return the function cgraph_node is alias of. | |
792 | Walk through thunk, too. | |
793 | When AVAILABILITY is non-NULL, get minimal availability in the chain. */ | |
794 | cgraph_node *function_symbol (enum availability *avail = NULL); | |
795 | ||
796 | /* Create node representing clone of N executed COUNT times. Decrease | |
797 | the execution counts from original node too. | |
798 | The new clone will have decl set to DECL that may or may not be the same | |
799 | as decl of N. | |
800 | ||
801 | When UPDATE_ORIGINAL is true, the counts are subtracted from the original | |
802 | function's profile to reflect the fact that part of execution is handled | |
803 | by node. | |
804 | When CALL_DUPLICATOIN_HOOK is true, the ipa passes are acknowledged about | |
805 | the new clone. Otherwise the caller is responsible for doing so later. | |
806 | ||
807 | If the new node is being inlined into another one, NEW_INLINED_TO should be | |
808 | the outline function the new one is (even indirectly) inlined to. | |
809 | All hooks will see this in node's global.inlined_to, when invoked. | |
810 | Can be NULL if the node is not inlined. */ | |
811 | cgraph_node *create_clone (tree decl, gcov_type count, int freq, | |
812 | bool update_original, | |
813 | vec<cgraph_edge *> redirect_callers, | |
814 | bool call_duplication_hook, | |
3dafb85c | 815 | cgraph_node *new_inlined_to, |
d52f5295 ML |
816 | bitmap args_to_skip); |
817 | ||
818 | /* Create callgraph node clone with new declaration. The actual body will | |
819 | be copied later at compilation stage. */ | |
820 | cgraph_node *create_virtual_clone (vec<cgraph_edge *> redirect_callers, | |
821 | vec<ipa_replace_map *, va_gc> *tree_map, | |
822 | bitmap args_to_skip, const char * suffix); | |
823 | ||
824 | /* cgraph node being removed from symbol table; see if its entry can be | |
825 | replaced by other inline clone. */ | |
826 | cgraph_node *find_replacement (void); | |
827 | ||
828 | /* Create a new cgraph node which is the new version of | |
829 | callgraph node. REDIRECT_CALLERS holds the callers | |
830 | edges which should be redirected to point to | |
831 | NEW_VERSION. ALL the callees edges of the node | |
832 | are cloned to the new version node. Return the new | |
833 | version node. | |
834 | ||
835 | If non-NULL BLOCK_TO_COPY determine what basic blocks | |
836 | was copied to prevent duplications of calls that are dead | |
837 | in the clone. */ | |
838 | ||
839 | cgraph_node *create_version_clone (tree new_decl, | |
840 | vec<cgraph_edge *> redirect_callers, | |
841 | bitmap bbs_to_copy); | |
842 | ||
843 | /* Perform function versioning. | |
844 | Function versioning includes copying of the tree and | |
845 | a callgraph update (creating a new cgraph node and updating | |
846 | its callees and callers). | |
847 | ||
848 | REDIRECT_CALLERS varray includes the edges to be redirected | |
849 | to the new version. | |
850 | ||
851 | TREE_MAP is a mapping of tree nodes we want to replace with | |
852 | new ones (according to results of prior analysis). | |
853 | ||
854 | If non-NULL ARGS_TO_SKIP determine function parameters to remove | |
855 | from new version. | |
856 | If SKIP_RETURN is true, the new version will return void. | |
857 | If non-NULL BLOCK_TO_COPY determine what basic blocks to copy. | |
858 | If non_NULL NEW_ENTRY determine new entry BB of the clone. | |
859 | ||
860 | Return the new version's cgraph node. */ | |
861 | cgraph_node *create_version_clone_with_body | |
862 | (vec<cgraph_edge *> redirect_callers, | |
863 | vec<ipa_replace_map *, va_gc> *tree_map, bitmap args_to_skip, | |
864 | bool skip_return, bitmap bbs_to_copy, basic_block new_entry_block, | |
865 | const char *clone_name); | |
866 | ||
867 | /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab | |
868 | corresponding to cgraph_node. */ | |
3dafb85c | 869 | cgraph_function_version_info *insert_new_function_version (void); |
d52f5295 ML |
870 | |
871 | /* Get the cgraph_function_version_info node corresponding to node. */ | |
3dafb85c | 872 | cgraph_function_version_info *function_version (void); |
d52f5295 ML |
873 | |
874 | /* Discover all functions and variables that are trivially needed, analyze | |
875 | them as well as all functions and variables referred by them */ | |
876 | void analyze (void); | |
877 | ||
878 | /* Add thunk alias into callgraph. The alias declaration is ALIAS and it | |
879 | aliases DECL with an adjustments made into the first parameter. | |
880 | See comments in thunk_adjust for detail on the parameters. */ | |
881 | cgraph_node * create_thunk (tree alias, tree, bool this_adjusting, | |
882 | HOST_WIDE_INT fixed_offset, | |
883 | HOST_WIDE_INT virtual_value, | |
884 | tree virtual_offset, | |
885 | tree real_alias); | |
886 | ||
887 | ||
888 | /* Return node that alias is aliasing. */ | |
889 | inline cgraph_node *get_alias_target (void); | |
890 | ||
891 | /* Given function symbol, walk the alias chain to return the function node | |
892 | is alias of. Do not walk through thunks. | |
893 | When AVAILABILITY is non-NULL, get minimal availability in the chain. */ | |
894 | ||
895 | cgraph_node *ultimate_alias_target (availability *availability = NULL); | |
896 | ||
897 | /* Expand thunk NODE to gimple if possible. | |
898 | When FORCE_GIMPLE_THUNK is true, gimple thunk is created and | |
899 | no assembler is produced. | |
900 | When OUTPUT_ASM_THUNK is true, also produce assembler for | |
901 | thunks that are not lowered. */ | |
902 | bool expand_thunk (bool output_asm_thunks, bool force_gimple_thunk); | |
903 | ||
3dafb85c ML |
904 | /* Assemble thunks and aliases associated to node. */ |
905 | void assemble_thunks_and_aliases (void); | |
906 | ||
907 | /* Expand function specified by node. */ | |
908 | void expand (void); | |
909 | ||
d52f5295 ML |
910 | /* As an GCC extension we allow redefinition of the function. The |
911 | semantics when both copies of bodies differ is not well defined. | |
912 | We replace the old body with new body so in unit at a time mode | |
913 | we always use new body, while in normal mode we may end up with | |
914 | old body inlined into some functions and new body expanded and | |
915 | inlined in others. */ | |
916 | void reset (void); | |
917 | ||
918 | /* Creates a wrapper from cgraph_node to TARGET node. Thunk is used for this | |
919 | kind of wrapper method. */ | |
920 | void create_wrapper (cgraph_node *target); | |
921 | ||
922 | /* Verify cgraph nodes of the cgraph node. */ | |
923 | void DEBUG_FUNCTION verify_node (void); | |
924 | ||
925 | /* Remove function from symbol table. */ | |
926 | void remove (void); | |
927 | ||
928 | /* Dump call graph node to file F. */ | |
929 | void dump (FILE *f); | |
930 | ||
931 | /* Dump call graph node to stderr. */ | |
932 | void DEBUG_FUNCTION debug (void); | |
933 | ||
934 | /* When doing LTO, read cgraph_node's body from disk if it is not already | |
935 | present. */ | |
70486010 JH |
936 | bool get_untransformed_body (void); |
937 | ||
938 | /* Prepare function body. When doing LTO, read cgraph_node's body from disk | |
939 | if it is not already present. When some IPA transformations are scheduled, | |
940 | apply them. */ | |
d52f5295 ML |
941 | bool get_body (void); |
942 | ||
943 | /* Release memory used to represent body of function. | |
944 | Use this only for functions that are released before being translated to | |
945 | target code (i.e. RTL). Functions that are compiled to RTL and beyond | |
946 | are free'd in final.c via free_after_compilation(). */ | |
bf898b30 | 947 | void release_body (bool keep_arguments = false); |
d52f5295 | 948 | |
8ccda8bc EB |
949 | /* Return the DECL_STRUCT_FUNCTION of the function. */ |
950 | struct function *get_fun (void); | |
951 | ||
d52f5295 ML |
952 | /* cgraph_node is no longer nested function; update cgraph accordingly. */ |
953 | void unnest (void); | |
954 | ||
955 | /* Bring cgraph node local. */ | |
956 | void make_local (void); | |
957 | ||
958 | /* Likewise indicate that a node is having address taken. */ | |
959 | void mark_address_taken (void); | |
960 | ||
961 | /* Set fialization priority to PRIORITY. */ | |
962 | void set_fini_priority (priority_type priority); | |
963 | ||
964 | /* Return the finalization priority. */ | |
965 | priority_type get_fini_priority (void); | |
966 | ||
967 | /* Create edge from a given function to CALLEE in the cgraph. */ | |
3dafb85c ML |
968 | cgraph_edge *create_edge (cgraph_node *callee, |
969 | gimple call_stmt, gcov_type count, | |
970 | int freq); | |
971 | ||
d52f5295 ML |
972 | /* Create an indirect edge with a yet-undetermined callee where the call |
973 | statement destination is a formal parameter of the caller with index | |
974 | PARAM_INDEX. */ | |
3dafb85c ML |
975 | cgraph_edge *create_indirect_edge (gimple call_stmt, int ecf_flags, |
976 | gcov_type count, int freq, | |
977 | bool compute_indirect_info = true); | |
d52f5295 ML |
978 | |
979 | /* Like cgraph_create_edge walk the clone tree and update all clones sharing | |
980 | same function body. If clones already have edge for OLD_STMT; only | |
981 | update the edge same way as cgraph_set_call_stmt_including_clones does. */ | |
3dafb85c | 982 | void create_edge_including_clones (cgraph_node *callee, |
d52f5295 ML |
983 | gimple old_stmt, gimple stmt, |
984 | gcov_type count, | |
985 | int freq, | |
986 | cgraph_inline_failed_t reason); | |
987 | ||
988 | /* Return the callgraph edge representing the GIMPLE_CALL statement | |
989 | CALL_STMT. */ | |
990 | cgraph_edge *get_edge (gimple call_stmt); | |
991 | ||
992 | /* Collect all callers of cgraph_node and its aliases that are known to lead | |
993 | to NODE (i.e. are not overwritable). */ | |
994 | vec<cgraph_edge *> collect_callers (void); | |
995 | ||
996 | /* Remove all callers from the node. */ | |
997 | void remove_callers (void); | |
998 | ||
999 | /* Remove all callees from the node. */ | |
1000 | void remove_callees (void); | |
1001 | ||
1002 | /* Return function availability. See cgraph.h for description of individual | |
1003 | return values. */ | |
1004 | enum availability get_availability (void); | |
1005 | ||
1006 | /* Set TREE_NOTHROW on cgraph_node's decl and on aliases of the node | |
1007 | if any to NOTHROW. */ | |
1008 | void set_nothrow_flag (bool nothrow); | |
1009 | ||
1010 | /* Set TREE_READONLY on cgraph_node's decl and on aliases of the node | |
1011 | if any to READONLY. */ | |
1012 | void set_const_flag (bool readonly, bool looping); | |
1013 | ||
1014 | /* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node | |
1015 | if any to PURE. */ | |
1016 | void set_pure_flag (bool pure, bool looping); | |
1017 | ||
d52f5295 ML |
1018 | /* Call calback on function and aliases associated to the function. |
1019 | When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are | |
1020 | skipped. */ | |
1021 | ||
1022 | bool call_for_symbol_and_aliases (bool (*callback) (cgraph_node *, | |
1023 | void *), | |
1024 | void *data, bool include_overwritable); | |
1025 | ||
1026 | /* Call calback on cgraph_node, thunks and aliases associated to NODE. | |
1027 | When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are | |
1028 | skipped. */ | |
1029 | bool call_for_symbol_thunks_and_aliases (bool (*callback) (cgraph_node *node, | |
1030 | void *data), | |
1031 | void *data, | |
1032 | bool include_overwritable); | |
1033 | ||
d52f5295 ML |
1034 | /* Likewise indicate that a node is needed, i.e. reachable via some |
1035 | external means. */ | |
1036 | inline void mark_force_output (void); | |
1037 | ||
1038 | /* Return true when function can be marked local. */ | |
1039 | bool local_p (void); | |
1040 | ||
1041 | /* Return true if cgraph_node can be made local for API change. | |
1042 | Extern inline functions and C++ COMDAT functions can be made local | |
1043 | at the expense of possible code size growth if function is used in multiple | |
1044 | compilation units. */ | |
1045 | bool can_be_local_p (void); | |
1046 | ||
1047 | /* Return true when cgraph_node can not return or throw and thus | |
1048 | it is safe to ignore its side effects for IPA analysis. */ | |
1049 | bool cannot_return_p (void); | |
1050 | ||
1051 | /* Return true when function cgraph_node and all its aliases are only called | |
1052 | directly. | |
1053 | i.e. it is not externally visible, address was not taken and | |
1054 | it is not used in any other non-standard way. */ | |
1055 | bool only_called_directly_p (void); | |
1056 | ||
1057 | /* Return true when function is only called directly or it has alias. | |
1058 | i.e. it is not externally visible, address was not taken and | |
1059 | it is not used in any other non-standard way. */ | |
1060 | inline bool only_called_directly_or_aliased_p (void); | |
1061 | ||
1062 | /* Return true when function cgraph_node can be expected to be removed | |
1063 | from program when direct calls in this compilation unit are removed. | |
1064 | ||
1065 | As a special case COMDAT functions are | |
1066 | cgraph_can_remove_if_no_direct_calls_p while the are not | |
1067 | cgraph_only_called_directly_p (it is possible they are called from other | |
1068 | unit) | |
1069 | ||
1070 | This function behaves as cgraph_only_called_directly_p because eliminating | |
1071 | all uses of COMDAT function does not make it necessarily disappear from | |
1072 | the program unless we are compiling whole program or we do LTO. In this | |
1073 | case we know we win since dynamic linking will not really discard the | |
1074 | linkonce section. */ | |
1075 | bool will_be_removed_from_program_if_no_direct_calls_p (void); | |
1076 | ||
1077 | /* Return true when function can be removed from callgraph | |
1078 | if all direct calls are eliminated. */ | |
1079 | bool can_remove_if_no_direct_calls_and_refs_p (void); | |
1080 | ||
1081 | /* Return true when function cgraph_node and its aliases can be removed from | |
1082 | callgraph if all direct calls are eliminated. */ | |
1083 | bool can_remove_if_no_direct_calls_p (void); | |
1084 | ||
1085 | /* Return true when callgraph node is a function with Gimple body defined | |
1086 | in current unit. Functions can also be define externally or they | |
1087 | can be thunks with no Gimple representation. | |
1088 | ||
1089 | Note that at WPA stage, the function body may not be present in memory. */ | |
1090 | inline bool has_gimple_body_p (void); | |
1091 | ||
1092 | /* Return true if function should be optimized for size. */ | |
1093 | bool optimize_for_size_p (void); | |
1094 | ||
1095 | /* Dump the callgraph to file F. */ | |
1096 | static void dump_cgraph (FILE *f); | |
1097 | ||
1098 | /* Dump the call graph to stderr. */ | |
3dafb85c ML |
1099 | static inline |
1100 | void debug_cgraph (void) | |
d52f5295 ML |
1101 | { |
1102 | dump_cgraph (stderr); | |
1103 | } | |
1104 | ||
1105 | /* Record that DECL1 and DECL2 are semantically identical function | |
1106 | versions. */ | |
1107 | static void record_function_versions (tree decl1, tree decl2); | |
1108 | ||
1109 | /* Remove the cgraph_function_version_info and cgraph_node for DECL. This | |
1110 | DECL is a duplicate declaration. */ | |
1111 | static void delete_function_version (tree decl); | |
1112 | ||
1113 | /* Add the function FNDECL to the call graph. | |
3dafb85c | 1114 | Unlike finalize_function, this function is intended to be used |
d52f5295 ML |
1115 | by middle end and allows insertion of new function at arbitrary point |
1116 | of compilation. The function can be either in high, low or SSA form | |
1117 | GIMPLE. | |
1118 | ||
1119 | The function is assumed to be reachable and have address taken (so no | |
1120 | API breaking optimizations are performed on it). | |
1121 | ||
1122 | Main work done by this function is to enqueue the function for later | |
1123 | processing to avoid need the passes to be re-entrant. */ | |
1124 | static void add_new_function (tree fndecl, bool lowered); | |
1125 | ||
1126 | /* Return callgraph node for given symbol and check it is a function. */ | |
1127 | static inline cgraph_node *get (const_tree decl) | |
1128 | { | |
1129 | gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL); | |
1130 | return dyn_cast <cgraph_node *> (symtab_node::get (decl)); | |
1131 | } | |
1132 | ||
3dafb85c ML |
1133 | /* DECL has been parsed. Take it, queue it, compile it at the whim of the |
1134 | logic in effect. If NO_COLLECT is true, then our caller cannot stand to | |
1135 | have the garbage collector run at the moment. We would need to either | |
1136 | create a new GC context, or just not compile right now. */ | |
1137 | static void finalize_function (tree, bool); | |
1138 | ||
d52f5295 ML |
1139 | /* Return cgraph node assigned to DECL. Create new one when needed. */ |
1140 | static cgraph_node * create (tree decl); | |
1141 | ||
d52f5295 ML |
1142 | /* Try to find a call graph node for declaration DECL and if it does not |
1143 | exist or if it corresponds to an inline clone, create a new one. */ | |
1144 | static cgraph_node * get_create (tree); | |
1145 | ||
3dafb85c ML |
1146 | /* Return local info for the compiled function. */ |
1147 | static cgraph_local_info *local_info (tree decl); | |
1148 | ||
1149 | /* Return global info for the compiled function. */ | |
1150 | static cgraph_global_info *global_info (tree); | |
1151 | ||
1152 | /* Return local info for the compiled function. */ | |
1153 | static cgraph_rtl_info *rtl_info (tree); | |
1154 | ||
d52f5295 ML |
1155 | /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME. |
1156 | Return NULL if there's no such node. */ | |
1157 | static cgraph_node *get_for_asmname (tree asmname); | |
1158 | ||
1159 | /* Attempt to mark ALIAS as an alias to DECL. Return alias node if | |
1160 | successful and NULL otherwise. | |
1161 | Same body aliases are output whenever the body of DECL is output, | |
1162 | and cgraph_node::get (ALIAS) transparently | |
1163 | returns cgraph_node::get (DECL). */ | |
1164 | static cgraph_node * create_same_body_alias (tree alias, tree decl); | |
1165 | ||
1166 | /* Worker for cgraph_can_remove_if_no_direct_calls_p. */ | |
1167 | static bool used_from_object_file_p_worker (cgraph_node *node, void *) | |
1168 | { | |
1169 | return node->used_from_object_file_p (); | |
1170 | } | |
1171 | ||
1172 | /* Return true when cgraph_node can not be local. | |
1173 | Worker for cgraph_local_node_p. */ | |
1174 | static bool non_local_p (cgraph_node *node, void *); | |
1175 | ||
1176 | /* Verify whole cgraph structure. */ | |
1177 | static void DEBUG_FUNCTION verify_cgraph_nodes (void); | |
1178 | ||
1179 | /* Worker to bring NODE local. */ | |
1180 | static bool make_local (cgraph_node *node, void *); | |
1181 | ||
1182 | /* Mark ALIAS as an alias to DECL. DECL_NODE is cgraph node representing | |
1183 | the function body is associated | |
1184 | with (not necessarily cgraph_node (DECL). */ | |
1185 | static cgraph_node *create_alias (tree alias, tree target); | |
1186 | ||
3dafb85c ML |
1187 | cgraph_edge *callees; |
1188 | cgraph_edge *callers; | |
e33c6cd6 MJ |
1189 | /* List of edges representing indirect calls with a yet undetermined |
1190 | callee. */ | |
3dafb85c | 1191 | cgraph_edge *indirect_calls; |
1c4a429a | 1192 | /* For nested functions points to function the node is nested in. */ |
d52f5295 | 1193 | cgraph_node *origin; |
1c4a429a | 1194 | /* Points to first nested function, if any. */ |
d52f5295 | 1195 | cgraph_node *nested; |
1c4a429a | 1196 | /* Pointer to the next function with same origin, if any. */ |
d52f5295 | 1197 | cgraph_node *next_nested; |
18c6ada9 | 1198 | /* Pointer to the next clone. */ |
d52f5295 ML |
1199 | cgraph_node *next_sibling_clone; |
1200 | cgraph_node *prev_sibling_clone; | |
1201 | cgraph_node *clones; | |
1202 | cgraph_node *clone_of; | |
d5e254e1 IE |
1203 | /* If instrumentation_clone is 1 then instrumented_version points |
1204 | to the original function used to make instrumented version. | |
1205 | Otherwise points to instrumented version of the function. */ | |
1206 | cgraph_node *instrumented_version; | |
1207 | /* If instrumentation_clone is 1 then orig_decl is the original | |
1208 | function declaration. */ | |
1209 | tree orig_decl; | |
70d539ce JH |
1210 | /* For functions with many calls sites it holds map from call expression |
1211 | to the edge to speed up cgraph_edge function. */ | |
2a22f99c | 1212 | hash_table<cgraph_edge_hasher> *GTY(()) call_site_hash; |
97ba0040 JH |
1213 | /* Declaration node used to be clone of. */ |
1214 | tree former_clone_of; | |
c22cacf3 | 1215 | |
0136f8f0 AH |
1216 | /* If this is a SIMD clone, this points to the SIMD specific |
1217 | information for it. */ | |
3dafb85c | 1218 | cgraph_simd_clone *simdclone; |
0136f8f0 | 1219 | /* If this function has SIMD clones, this points to the first clone. */ |
d52f5295 | 1220 | cgraph_node *simd_clones; |
0136f8f0 | 1221 | |
0e3776db JH |
1222 | /* Interprocedural passes scheduled to have their transform functions |
1223 | applied next time we execute local pass on them. We maintain it | |
1224 | per-function in order to allow IPA passes to introduce new functions. */ | |
9771b263 | 1225 | vec<ipa_opt_pass> GTY((skip)) ipa_transforms_to_apply; |
0e3776db | 1226 | |
3dafb85c ML |
1227 | cgraph_local_info local; |
1228 | cgraph_global_info global; | |
1229 | cgraph_rtl_info rtl; | |
1230 | cgraph_clone_info clone; | |
1231 | cgraph_thunk_info thunk; | |
c22cacf3 | 1232 | |
e42922b1 JH |
1233 | /* Expected number of executions: calculated in profile.c. */ |
1234 | gcov_type count; | |
db0bf14f JH |
1235 | /* How to scale counts at materialization time; used to merge |
1236 | LTO units with different number of profile runs. */ | |
1237 | int count_materialization_scale; | |
95c755e9 JH |
1238 | /* Unique id of the node. */ |
1239 | int uid; | |
2fa3d31b JH |
1240 | /* ID assigned by the profiling. */ |
1241 | unsigned int profile_id; | |
86ce5d2f ML |
1242 | /* Time profiler: first run of function. */ |
1243 | int tp_first_run; | |
3691626c | 1244 | |
6b20f353 DS |
1245 | /* Set when decl is an abstract function pointed to by the |
1246 | ABSTRACT_DECL_ORIGIN of a reachable function. */ | |
c0c123ef | 1247 | unsigned used_as_abstract_origin : 1; |
50674e96 | 1248 | /* Set once the function is lowered (i.e. its CFG is built). */ |
b4e19405 | 1249 | unsigned lowered : 1; |
25c84396 RH |
1250 | /* Set once the function has been instantiated and its callee |
1251 | lists created. */ | |
257eb6e3 | 1252 | unsigned process : 1; |
5fefcf92 JH |
1253 | /* How commonly executed the node is. Initialized during branch |
1254 | probabilities pass. */ | |
1255 | ENUM_BITFIELD (node_frequency) frequency : 2; | |
844db5d0 JH |
1256 | /* True when function can only be called at startup (from static ctor). */ |
1257 | unsigned only_called_at_startup : 1; | |
1258 | /* True when function can only be called at startup (from static dtor). */ | |
1259 | unsigned only_called_at_exit : 1; | |
0a35513e AH |
1260 | /* True when function is the transactional clone of a function which |
1261 | is called only from inside transactions. */ | |
1262 | /* ?? We should be able to remove this. We have enough bits in | |
1263 | cgraph to calculate it. */ | |
1264 | unsigned tm_clone : 1; | |
3649b9b7 ST |
1265 | /* True if this decl is a dispatcher for function versions. */ |
1266 | unsigned dispatcher_function : 1; | |
1f26ac87 JM |
1267 | /* True if this decl calls a COMDAT-local function. This is set up in |
1268 | compute_inline_parameters and inline_call. */ | |
1269 | unsigned calls_comdat_local : 1; | |
b84d4347 ML |
1270 | /* True if node has been created by merge operation in IPA-ICF. */ |
1271 | unsigned icf_merged: 1; | |
d5e254e1 IE |
1272 | /* True when function is clone created for Pointer Bounds Checker |
1273 | instrumentation. */ | |
1274 | unsigned instrumentation_clone : 1; | |
8413ca87 JJ |
1275 | /* True if call to node can't result in a call to free, munmap or |
1276 | other operation that could make previously non-trapping memory | |
1277 | accesses trapping. */ | |
1278 | unsigned nonfreeing_fn : 1; | |
3649b9b7 ST |
1279 | }; |
1280 | ||
fed5ae11 DK |
1281 | /* A cgraph node set is a collection of cgraph nodes. A cgraph node |
1282 | can appear in multiple sets. */ | |
1cb1a99f | 1283 | struct cgraph_node_set_def |
fed5ae11 | 1284 | { |
b787e7a2 | 1285 | hash_map<cgraph_node *, size_t> *map; |
d52f5295 | 1286 | vec<cgraph_node *> nodes; |
fed5ae11 DK |
1287 | }; |
1288 | ||
d52f5295 ML |
1289 | typedef cgraph_node_set_def *cgraph_node_set; |
1290 | typedef struct varpool_node_set_def *varpool_node_set; | |
2942c502 | 1291 | |
d52f5295 | 1292 | class varpool_node; |
2942c502 JH |
1293 | |
1294 | /* A varpool node set is a collection of varpool nodes. A varpool node | |
1295 | can appear in multiple sets. */ | |
1cb1a99f | 1296 | struct varpool_node_set_def |
2942c502 | 1297 | { |
b787e7a2 | 1298 | hash_map<varpool_node *, size_t> * map; |
d52f5295 | 1299 | vec<varpool_node *> nodes; |
2942c502 JH |
1300 | }; |
1301 | ||
fed5ae11 | 1302 | /* Iterator structure for cgraph node sets. */ |
84562394 | 1303 | struct cgraph_node_set_iterator |
fed5ae11 DK |
1304 | { |
1305 | cgraph_node_set set; | |
1306 | unsigned index; | |
84562394 | 1307 | }; |
fed5ae11 | 1308 | |
2942c502 | 1309 | /* Iterator structure for varpool node sets. */ |
84562394 | 1310 | struct varpool_node_set_iterator |
2942c502 JH |
1311 | { |
1312 | varpool_node_set set; | |
1313 | unsigned index; | |
84562394 | 1314 | }; |
2942c502 | 1315 | |
ba392339 JH |
1316 | /* Context of polymorphic call. It represent information about the type of |
1317 | instance that may reach the call. This is used by ipa-devirt walkers of the | |
1318 | type inheritance graph. */ | |
1319 | ||
1320 | class GTY(()) ipa_polymorphic_call_context { | |
1321 | public: | |
1322 | /* The called object appears in an object of type OUTER_TYPE | |
1323 | at offset OFFSET. When information is not 100% reliable, we | |
1324 | use SPECULATIVE_OUTER_TYPE and SPECULATIVE_OFFSET. */ | |
1325 | HOST_WIDE_INT offset; | |
1326 | HOST_WIDE_INT speculative_offset; | |
1327 | tree outer_type; | |
1328 | tree speculative_outer_type; | |
1329 | /* True if outer object may be in construction or destruction. */ | |
4081ada2 | 1330 | unsigned maybe_in_construction : 1; |
ba392339 | 1331 | /* True if outer object may be of derived type. */ |
4081ada2 | 1332 | unsigned maybe_derived_type : 1; |
ba392339 JH |
1333 | /* True if speculative outer object may be of derived type. We always |
1334 | speculate that construction does not happen. */ | |
4081ada2 | 1335 | unsigned speculative_maybe_derived_type : 1; |
ba392339 JH |
1336 | /* True if the context is invalid and all calls should be redirected |
1337 | to BUILTIN_UNREACHABLE. */ | |
4081ada2 JH |
1338 | unsigned invalid : 1; |
1339 | /* True if the outer type is dynamic. */ | |
1340 | unsigned dynamic : 1; | |
ba392339 JH |
1341 | |
1342 | /* Build empty "I know nothing" context. */ | |
1343 | ipa_polymorphic_call_context (); | |
1344 | /* Build polymorphic call context for indirect call E. */ | |
1345 | ipa_polymorphic_call_context (cgraph_edge *e); | |
1346 | /* Build polymorphic call context for IP invariant CST. | |
1347 | If specified, OTR_TYPE specify the type of polymorphic call | |
1348 | that takes CST+OFFSET as a prameter. */ | |
1349 | ipa_polymorphic_call_context (tree cst, tree otr_type = NULL, | |
1350 | HOST_WIDE_INT offset = 0); | |
1351 | /* Build context for pointer REF contained in FNDECL at statement STMT. | |
1352 | if INSTANCE is non-NULL, return pointer to the object described by | |
1353 | the context. */ | |
1354 | ipa_polymorphic_call_context (tree fndecl, tree ref, gimple stmt, | |
1355 | tree *instance = NULL); | |
1356 | ||
1357 | /* Look for vtable stores or constructor calls to work out dynamic type | |
1358 | of memory location. */ | |
1359 | bool get_dynamic_type (tree, tree, tree, gimple); | |
1360 | ||
1361 | /* Make context non-speculative. */ | |
1362 | void clear_speculation (); | |
1363 | ||
6ff65dd7 MJ |
1364 | /* Produce context specifying all derrived types of OTR_TYPE. If OTR_TYPE is |
1365 | NULL, the context is set to dummy "I know nothing" setting. */ | |
1366 | void clear_outer_type (tree otr_type = NULL); | |
1367 | ||
ba392339 | 1368 | /* Walk container types and modify context to point to actual class |
67a1b94c JH |
1369 | containing OTR_TYPE (if non-NULL) as base class. |
1370 | Return true if resulting context is valid. | |
1371 | ||
1372 | When CONSIDER_PLACEMENT_NEW is false, reject contexts that may be made | |
1373 | valid only via alocation of new polymorphic type inside by means | |
1374 | of placement new. | |
1375 | ||
1376 | When CONSIDER_BASES is false, only look for actual fields, not base types | |
1377 | of TYPE. */ | |
1378 | bool restrict_to_inner_class (tree otr_type, | |
1379 | bool consider_placement_new = true, | |
1380 | bool consider_bases = true); | |
1381 | ||
1382 | /* Adjust all offsets in contexts by given number of bits. */ | |
1383 | void offset_by (HOST_WIDE_INT); | |
4081ada2 JH |
1384 | /* Use when we can not track dynamic type change. This speculatively assume |
1385 | type change is not happening. */ | |
f9bb202b | 1386 | void possible_dynamic_type_change (bool, tree otr_type = NULL); |
67a1b94c JH |
1387 | /* Assume that both THIS and a given context is valid and strenghten THIS |
1388 | if possible. Return true if any strenghtening was made. | |
1389 | If actual type the context is being used in is known, OTR_TYPE should be | |
1390 | set accordingly. This improves quality of combined result. */ | |
1391 | bool combine_with (ipa_polymorphic_call_context, tree otr_type = NULL); | |
1392 | ||
1393 | /* Return TRUE if context is fully useless. */ | |
1394 | bool useless_p () const; | |
44210a96 MJ |
1395 | /* Return TRUE if this context conveys the same information as X. */ |
1396 | bool equal_to (const ipa_polymorphic_call_context &x) const; | |
ba392339 | 1397 | |
44210a96 MJ |
1398 | /* Dump human readable context to F. If NEWLINE is true, it will be |
1399 | terminated by a newline. */ | |
1400 | void dump (FILE *f, bool newline = true) const; | |
ba392339 JH |
1401 | void DEBUG_FUNCTION debug () const; |
1402 | ||
1403 | /* LTO streaming. */ | |
1404 | void stream_out (struct output_block *) const; | |
1405 | void stream_in (struct lto_input_block *, struct data_in *data_in); | |
1406 | ||
1407 | private: | |
67a1b94c | 1408 | bool combine_speculation_with (tree, HOST_WIDE_INT, bool, tree); |
ba392339 JH |
1409 | void set_by_decl (tree, HOST_WIDE_INT); |
1410 | bool set_by_invariant (tree, tree, HOST_WIDE_INT); | |
67a1b94c | 1411 | bool speculation_consistent_p (tree, HOST_WIDE_INT, bool, tree); |
4081ada2 | 1412 | void make_speculative (tree otr_type = NULL); |
ba392339 JH |
1413 | }; |
1414 | ||
e33c6cd6 MJ |
1415 | /* Structure containing additional information about an indirect call. */ |
1416 | ||
1417 | struct GTY(()) cgraph_indirect_call_info | |
1418 | { | |
ba392339 JH |
1419 | /* When agg_content is set, an offset where the call pointer is located |
1420 | within the aggregate. */ | |
1421 | HOST_WIDE_INT offset; | |
1422 | /* Context of the polymorphic call; use only when POLYMORPHIC flag is set. */ | |
1423 | ipa_polymorphic_call_context context; | |
b258210c MJ |
1424 | /* OBJ_TYPE_REF_TOKEN of a polymorphic call (if polymorphic is set). */ |
1425 | HOST_WIDE_INT otr_token; | |
1426 | /* Type of the object from OBJ_TYPE_REF_OBJECT. */ | |
ba392339 | 1427 | tree otr_type; |
e33c6cd6 MJ |
1428 | /* Index of the parameter that is called. */ |
1429 | int param_index; | |
5f902d76 JH |
1430 | /* ECF flags determined from the caller. */ |
1431 | int ecf_flags; | |
634ab819 JH |
1432 | /* Profile_id of common target obtrained from profile. */ |
1433 | int common_target_id; | |
1434 | /* Probability that call will land in function with COMMON_TARGET_ID. */ | |
1435 | int common_target_probability; | |
b258210c MJ |
1436 | |
1437 | /* Set when the call is a virtual call with the parameter being the | |
1438 | associated object pointer rather than a simple direct call. */ | |
1439 | unsigned polymorphic : 1; | |
8b7773a4 MJ |
1440 | /* Set when the call is a call of a pointer loaded from contents of an |
1441 | aggregate at offset. */ | |
1442 | unsigned agg_contents : 1; | |
c13bc3d9 MJ |
1443 | /* Set when this is a call through a member pointer. */ |
1444 | unsigned member_ptr : 1; | |
8b7773a4 MJ |
1445 | /* When the previous bit is set, this one determines whether the destination |
1446 | is loaded from a parameter passed by reference. */ | |
1447 | unsigned by_ref : 1; | |
0127c169 JH |
1448 | /* For polymorphic calls this specify whether the virtual table pointer |
1449 | may have changed in between function entry and the call. */ | |
1450 | unsigned vptr_changed : 1; | |
e33c6cd6 MJ |
1451 | }; |
1452 | ||
2a22f99c TS |
1453 | struct GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"), |
1454 | for_user)) cgraph_edge { | |
3dafb85c ML |
1455 | friend class cgraph_node; |
1456 | ||
1457 | /* Remove the edge in the cgraph. */ | |
1458 | void remove (void); | |
1459 | ||
1460 | /* Change field call_stmt of edge to NEW_STMT. | |
1461 | If UPDATE_SPECULATIVE and E is any component of speculative | |
1462 | edge, then update all components. */ | |
1463 | void set_call_stmt (gimple new_stmt, bool update_speculative = true); | |
1464 | ||
1465 | /* Redirect callee of the edge to N. The function does not update underlying | |
1466 | call expression. */ | |
1467 | void redirect_callee (cgraph_node *n); | |
1468 | ||
1469 | /* Make an indirect edge with an unknown callee an ordinary edge leading to | |
1470 | CALLEE. DELTA is an integer constant that is to be added to the this | |
1471 | pointer (first parameter) to compensate for skipping | |
1472 | a thunk adjustment. */ | |
1473 | cgraph_edge *make_direct (cgraph_node *callee); | |
1474 | ||
1475 | /* Turn edge into speculative call calling N2. Update | |
1476 | the profile so the direct call is taken COUNT times | |
1477 | with FREQUENCY. */ | |
1478 | cgraph_edge *make_speculative (cgraph_node *n2, gcov_type direct_count, | |
1479 | int direct_frequency); | |
1480 | ||
1481 | /* Given speculative call edge, return all three components. */ | |
1482 | void speculative_call_info (cgraph_edge *&direct, cgraph_edge *&indirect, | |
1483 | ipa_ref *&reference); | |
1484 | ||
1485 | /* Speculative call edge turned out to be direct call to CALLE_DECL. | |
1486 | Remove the speculative call sequence and return edge representing the call. | |
1487 | It is up to caller to redirect the call as appropriate. */ | |
1488 | cgraph_edge *resolve_speculation (tree callee_decl = NULL); | |
1489 | ||
1490 | /* If necessary, change the function declaration in the call statement | |
1491 | associated with the edge so that it corresponds to the edge callee. */ | |
1492 | gimple redirect_call_stmt_to_callee (void); | |
1493 | ||
1494 | /* Create clone of edge in the node N represented | |
1495 | by CALL_EXPR the callgraph. */ | |
1496 | cgraph_edge * clone (cgraph_node *n, gimple call_stmt, unsigned stmt_uid, | |
1497 | gcov_type count_scale, int freq_scale, bool update_original); | |
1498 | ||
1499 | /* Return true when call of edge can not lead to return from caller | |
1500 | and thus it is safe to ignore its side effects for IPA analysis | |
1501 | when computing side effects of the caller. */ | |
1502 | bool cannot_lead_to_return_p (void); | |
1503 | ||
1504 | /* Return true when the edge represents a direct recursion. */ | |
1505 | bool recursive_p (void); | |
1506 | ||
1507 | /* Return true if the call can be hot. */ | |
1508 | bool maybe_hot_p (void); | |
1509 | ||
1510 | /* Rebuild cgraph edges for current function node. This needs to be run after | |
1511 | passes that don't update the cgraph. */ | |
1512 | static unsigned int rebuild_edges (void); | |
1513 | ||
1514 | /* Rebuild cgraph references for current function node. This needs to be run | |
1515 | after passes that don't update the cgraph. */ | |
1516 | static void rebuild_references (void); | |
1517 | ||
6009ee7b MJ |
1518 | /* Expected number of executions: calculated in profile.c. */ |
1519 | gcov_type count; | |
d52f5295 ML |
1520 | cgraph_node *caller; |
1521 | cgraph_node *callee; | |
3dafb85c ML |
1522 | cgraph_edge *prev_caller; |
1523 | cgraph_edge *next_caller; | |
1524 | cgraph_edge *prev_callee; | |
1525 | cgraph_edge *next_callee; | |
726a989a | 1526 | gimple call_stmt; |
e33c6cd6 MJ |
1527 | /* Additional information about an indirect call. Not cleared when an edge |
1528 | becomes direct. */ | |
3dafb85c | 1529 | cgraph_indirect_call_info *indirect_info; |
18c6ada9 | 1530 | PTR GTY ((skip (""))) aux; |
61a05df1 JH |
1531 | /* When equal to CIF_OK, inline this call. Otherwise, points to the |
1532 | explanation why function was not inlined. */ | |
84562394 | 1533 | enum cgraph_inline_failed_t inline_failed; |
6009ee7b MJ |
1534 | /* The stmt_uid of call_stmt. This is used by LTO to recover the call_stmt |
1535 | when the function is serialized in. */ | |
1536 | unsigned int lto_stmt_uid; | |
b8698a0f | 1537 | /* Expected frequency of executions within the function. |
45a80bb9 JH |
1538 | When set to CGRAPH_FREQ_BASE, the edge is expected to be called once |
1539 | per function call. The range is 0 to CGRAPH_FREQ_MAX. */ | |
1540 | int frequency; | |
6009ee7b MJ |
1541 | /* Unique id of the edge. */ |
1542 | int uid; | |
e33c6cd6 MJ |
1543 | /* Whether this edge was made direct by indirect inlining. */ |
1544 | unsigned int indirect_inlining_edge : 1; | |
1545 | /* Whether this edge describes an indirect call with an undetermined | |
1546 | callee. */ | |
1547 | unsigned int indirect_unknown_callee : 1; | |
1548 | /* Whether this edge is still a dangling */ | |
d7f09764 DN |
1549 | /* True if the corresponding CALL stmt cannot be inlined. */ |
1550 | unsigned int call_stmt_cannot_inline_p : 1; | |
2505c5ed JH |
1551 | /* Can this call throw externally? */ |
1552 | unsigned int can_throw_external : 1; | |
042ae7d2 JH |
1553 | /* Edges with SPECULATIVE flag represents indirect calls that was |
1554 | speculatively turned into direct (i.e. by profile feedback). | |
1555 | The final code sequence will have form: | |
1556 | ||
1557 | if (call_target == expected_fn) | |
1558 | expected_fn (); | |
1559 | else | |
1560 | call_target (); | |
1561 | ||
1562 | Every speculative call is represented by three components attached | |
1563 | to a same call statement: | |
1564 | 1) a direct call (to expected_fn) | |
1565 | 2) an indirect call (to call_target) | |
1566 | 3) a IPA_REF_ADDR refrence to expected_fn. | |
1567 | ||
1568 | Optimizers may later redirect direct call to clone, so 1) and 3) | |
1569 | do not need to necesarily agree with destination. */ | |
1570 | unsigned int speculative : 1; | |
f9bb202b JH |
1571 | /* Set to true when caller is a constructor or destructor of polymorphic |
1572 | type. */ | |
1573 | unsigned in_polymorphic_cdtor : 1; | |
3dafb85c ML |
1574 | |
1575 | private: | |
1576 | /* Remove the edge from the list of the callers of the callee. */ | |
1577 | void remove_caller (void); | |
1578 | ||
1579 | /* Remove the edge from the list of the callees of the caller. */ | |
1580 | void remove_callee (void); | |
1c4a429a JH |
1581 | }; |
1582 | ||
45a80bb9 JH |
1583 | #define CGRAPH_FREQ_BASE 1000 |
1584 | #define CGRAPH_FREQ_MAX 100000 | |
1585 | ||
8a4a83ed JH |
1586 | /* The varpool data structure. |
1587 | Each static variable decl has assigned varpool_node. */ | |
e69529cd | 1588 | |
5e20cdc9 | 1589 | class GTY((tag ("SYMTAB_VARIABLE"))) varpool_node : public symtab_node { |
a3bfa8b8 | 1590 | public: |
9041d2e6 ML |
1591 | /* Dump given varpool node to F. */ |
1592 | void dump (FILE *f); | |
1593 | ||
1594 | /* Dump given varpool node to stderr. */ | |
1595 | void DEBUG_FUNCTION debug (void); | |
1596 | ||
1597 | /* Remove variable from symbol table. */ | |
1598 | void remove (void); | |
1599 | ||
1600 | /* Remove node initializer when it is no longer needed. */ | |
1601 | void remove_initializer (void); | |
1602 | ||
1603 | void analyze (void); | |
1604 | ||
1605 | /* Return variable availability. */ | |
1606 | availability get_availability (void); | |
1607 | ||
1608 | /* When doing LTO, read variable's constructor from disk if | |
1609 | it is not already present. */ | |
1610 | tree get_constructor (void); | |
1611 | ||
1612 | /* Return true if variable has constructor that can be used for folding. */ | |
1613 | bool ctor_useable_for_folding_p (void); | |
1614 | ||
1615 | /* For given variable pool node, walk the alias chain to return the function | |
1616 | the variable is alias of. Do not walk through thunks. | |
1617 | When AVAILABILITY is non-NULL, get minimal availability in the chain. */ | |
1618 | inline varpool_node *ultimate_alias_target | |
1619 | (availability *availability = NULL); | |
1620 | ||
1621 | /* Return node that alias is aliasing. */ | |
1622 | inline varpool_node *get_alias_target (void); | |
1623 | ||
1624 | /* Output one variable, if necessary. Return whether we output it. */ | |
1625 | bool assemble_decl (void); | |
1626 | ||
1627 | /* For variables in named sections make sure get_variable_section | |
1628 | is called before we switch to those sections. Then section | |
1629 | conflicts between read-only and read-only requiring relocations | |
1630 | sections can be resolved. */ | |
1631 | void finalize_named_section_flags (void); | |
1632 | ||
1633 | /* Call calback on varpool symbol and aliases associated to varpool symbol. | |
1634 | When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are | |
1635 | skipped. */ | |
1636 | bool call_for_node_and_aliases (bool (*callback) (varpool_node *, void *), | |
1637 | void *data, | |
1638 | bool include_overwritable); | |
1639 | ||
1640 | /* Return true when variable should be considered externally visible. */ | |
1641 | bool externally_visible_p (void); | |
1642 | ||
1643 | /* Return true when all references to variable must be visible | |
1644 | in ipa_ref_list. | |
1645 | i.e. if the variable is not externally visible or not used in some magic | |
1646 | way (asm statement or such). | |
1647 | The magic uses are all summarized in force_output flag. */ | |
1648 | inline bool all_refs_explicit_p (); | |
1649 | ||
1650 | /* Return true when variable can be removed from variable pool | |
1651 | if all direct calls are eliminated. */ | |
1652 | inline bool can_remove_if_no_refs_p (void); | |
1653 | ||
3dafb85c ML |
1654 | /* Add the variable DECL to the varpool. |
1655 | Unlike finalize_decl function is intended to be used | |
1656 | by middle end and allows insertion of new variable at arbitrary point | |
1657 | of compilation. */ | |
1658 | static void add (tree decl); | |
1659 | ||
9041d2e6 ML |
1660 | /* Return varpool node for given symbol and check it is a function. */ |
1661 | static inline varpool_node *get (const_tree decl); | |
1662 | ||
1663 | /* Mark DECL as finalized. By finalizing the declaration, frontend instruct | |
1664 | the middle end to output the variable to asm file, if needed or externally | |
1665 | visible. */ | |
1666 | static void finalize_decl (tree decl); | |
1667 | ||
9041d2e6 ML |
1668 | /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful. |
1669 | Extra name aliases are output whenever DECL is output. */ | |
1670 | static varpool_node * create_extra_name_alias (tree alias, tree decl); | |
1671 | ||
1672 | /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful. | |
1673 | Extra name aliases are output whenever DECL is output. */ | |
1674 | static varpool_node * create_alias (tree, tree); | |
1675 | ||
1676 | /* Dump the variable pool to F. */ | |
1677 | static void dump_varpool (FILE *f); | |
1678 | ||
1679 | /* Dump the variable pool to stderr. */ | |
1680 | static void DEBUG_FUNCTION debug_varpool (void); | |
1681 | ||
1682 | /* Allocate new callgraph node and insert it into basic data structures. */ | |
1683 | static varpool_node *create_empty (void); | |
1684 | ||
1685 | /* Return varpool node assigned to DECL. Create new one when needed. */ | |
1686 | static varpool_node *get_create (tree decl); | |
1687 | ||
1688 | /* Given an assembler name, lookup node. */ | |
1689 | static varpool_node *get_for_asmname (tree asmname); | |
1690 | ||
6b02a499 | 1691 | /* Set when variable is scheduled to be assembled. */ |
b4e19405 | 1692 | unsigned output : 1; |
eb1d8159 | 1693 | |
d5e254e1 IE |
1694 | /* Set when variable has statically initialized pointer |
1695 | or is a static bounds variable and needs initalization. */ | |
1696 | unsigned need_bounds_init : 1; | |
1697 | ||
59b36ecf JJ |
1698 | /* Set if the variable is dynamically initialized, except for |
1699 | function local statics. */ | |
1700 | unsigned dynamically_initialized : 1; | |
56363ffd JH |
1701 | |
1702 | ENUM_BITFIELD(tls_model) tls_model : 3; | |
eb6a09a7 JH |
1703 | |
1704 | /* Set if the variable is known to be used by single function only. | |
1705 | This is computed by ipa_signle_use pass and used by late optimizations | |
1706 | in places where optimization would be valid for local static variable | |
1707 | if we did not do any inter-procedural code movement. */ | |
1708 | unsigned used_by_single_function : 1; | |
d52f5295 | 1709 | |
9041d2e6 ML |
1710 | private: |
1711 | /* Assemble thunks and aliases associated to varpool node. */ | |
1712 | void assemble_aliases (void); | |
e69529cd JH |
1713 | }; |
1714 | ||
65d630d4 | 1715 | /* Every top level asm statement is put into a asm_node. */ |
474eccc6 | 1716 | |
65d630d4 | 1717 | struct GTY(()) asm_node { |
3dafb85c ML |
1718 | |
1719 | ||
474eccc6 | 1720 | /* Next asm node. */ |
3dafb85c | 1721 | asm_node *next; |
474eccc6 ILT |
1722 | /* String for this asm node. */ |
1723 | tree asm_str; | |
1724 | /* Ordering of all cgraph nodes. */ | |
1725 | int order; | |
1726 | }; | |
1727 | ||
5d59b5e1 LC |
1728 | /* Report whether or not THIS symtab node is a function, aka cgraph_node. */ |
1729 | ||
1730 | template <> | |
1731 | template <> | |
1732 | inline bool | |
7de90a6c | 1733 | is_a_helper <cgraph_node *>::test (symtab_node *p) |
5d59b5e1 | 1734 | { |
d52f5295 | 1735 | return p && p->type == SYMTAB_FUNCTION; |
5d59b5e1 LC |
1736 | } |
1737 | ||
1738 | /* Report whether or not THIS symtab node is a vriable, aka varpool_node. */ | |
1739 | ||
1740 | template <> | |
1741 | template <> | |
1742 | inline bool | |
7de90a6c | 1743 | is_a_helper <varpool_node *>::test (symtab_node *p) |
5d59b5e1 | 1744 | { |
d52f5295 | 1745 | return p && p->type == SYMTAB_VARIABLE; |
5d59b5e1 LC |
1746 | } |
1747 | ||
3dafb85c ML |
1748 | /* Macros to access the next item in the list of free cgraph nodes and |
1749 | edges. */ | |
1750 | #define NEXT_FREE_NODE(NODE) dyn_cast<cgraph_node *> ((NODE)->next) | |
1751 | #define SET_NEXT_FREE_NODE(NODE,NODE2) ((NODE))->next = NODE2 | |
1752 | #define NEXT_FREE_EDGE(EDGE) (EDGE)->prev_caller | |
1753 | ||
1754 | typedef void (*cgraph_edge_hook)(cgraph_edge *, void *); | |
1755 | typedef void (*cgraph_node_hook)(cgraph_node *, void *); | |
1756 | typedef void (*varpool_node_hook)(varpool_node *, void *); | |
1757 | typedef void (*cgraph_2edge_hook)(cgraph_edge *, cgraph_edge *, void *); | |
1758 | typedef void (*cgraph_2node_hook)(cgraph_node *, cgraph_node *, void *); | |
1759 | ||
1760 | struct cgraph_edge_hook_list; | |
1761 | struct cgraph_node_hook_list; | |
1762 | struct varpool_node_hook_list; | |
1763 | struct cgraph_2edge_hook_list; | |
1764 | struct cgraph_2node_hook_list; | |
1765 | ||
1766 | /* Map from a symbol to initialization/finalization priorities. */ | |
1767 | struct GTY(()) symbol_priority_map { | |
3dafb85c ML |
1768 | priority_type init; |
1769 | priority_type fini; | |
1770 | }; | |
1771 | ||
1772 | enum symtab_state | |
f45e0ad1 | 1773 | { |
66058468 | 1774 | /* Frontend is parsing and finalizing functions. */ |
3dafb85c | 1775 | PARSING, |
f45e0ad1 | 1776 | /* Callgraph is being constructed. It is safe to add new functions. */ |
3dafb85c | 1777 | CONSTRUCTION, |
ca0f62a8 | 1778 | /* Callgraph is being at LTO time. */ |
3dafb85c | 1779 | LTO_STREAMING, |
f45e0ad1 | 1780 | /* Callgraph is built and IPA passes are being run. */ |
3dafb85c | 1781 | IPA, |
7a388ee4 | 1782 | /* Callgraph is built and all functions are transformed to SSA form. */ |
3dafb85c | 1783 | IPA_SSA, |
f45e0ad1 | 1784 | /* Functions are now ordered and being passed to RTL expanders. */ |
3dafb85c | 1785 | EXPANSION, |
f45e0ad1 | 1786 | /* All cgraph expansion is done. */ |
3dafb85c | 1787 | FINISHED |
f45e0ad1 | 1788 | }; |
1c4a429a | 1789 | |
2a22f99c TS |
1790 | struct asmname_hasher |
1791 | { | |
1792 | typedef symtab_node *value_type; | |
1793 | typedef const_tree compare_type; | |
1794 | typedef int store_values_directly; | |
1795 | ||
1796 | static hashval_t hash (symtab_node *n); | |
1797 | static bool equal (symtab_node *n, const_tree t); | |
1798 | static void ggc_mx (symtab_node *n); | |
1799 | static void pch_nx (symtab_node *&); | |
1800 | static void pch_nx (symtab_node *&, gt_pointer_operator, void *); | |
1801 | static void remove (symtab_node *) {} | |
1802 | }; | |
1803 | ||
3dafb85c ML |
1804 | class GTY((tag ("SYMTAB"))) symbol_table |
1805 | { | |
1806 | public: | |
1807 | friend class symtab_node; | |
1808 | friend class cgraph_node; | |
1809 | friend class cgraph_edge; | |
1810 | ||
1811 | /* Initialize callgraph dump file. */ | |
c582198b | 1812 | void initialize (void); |
3dafb85c ML |
1813 | |
1814 | /* Register a top-level asm statement ASM_STR. */ | |
1815 | inline asm_node *finalize_toplevel_asm (tree asm_str); | |
1816 | ||
1817 | /* Analyze the whole compilation unit once it is parsed completely. */ | |
1818 | void finalize_compilation_unit (void); | |
1819 | ||
1820 | /* C++ frontend produce same body aliases all over the place, even before PCH | |
1821 | gets streamed out. It relies on us linking the aliases with their function | |
1822 | in order to do the fixups, but ipa-ref is not PCH safe. Consequentely we | |
1823 | first produce aliases without links, but once C++ FE is sure he won't sream | |
1824 | PCH we build the links via this function. */ | |
1825 | void process_same_body_aliases (void); | |
1826 | ||
1827 | /* Perform simple optimizations based on callgraph. */ | |
1828 | void compile (void); | |
1829 | ||
1830 | /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these | |
1831 | functions into callgraph in a way so they look like ordinary reachable | |
1832 | functions inserted into callgraph already at construction time. */ | |
1833 | void process_new_functions (void); | |
1834 | ||
1835 | /* Once all functions from compilation unit are in memory, produce all clones | |
1836 | and update all calls. We might also do this on demand if we don't want to | |
1837 | bring all functions to memory prior compilation, but current WHOPR | |
1838 | implementation does that and it is is bit easier to keep everything right | |
1839 | in this order. */ | |
1840 | void materialize_all_clones (void); | |
1841 | ||
1842 | /* Register a symbol NODE. */ | |
1843 | inline void register_symbol (symtab_node *node); | |
1844 | ||
1845 | inline void | |
1846 | clear_asm_symbols (void) | |
1847 | { | |
1848 | asmnodes = NULL; | |
1849 | asm_last_node = NULL; | |
1850 | } | |
1851 | ||
1852 | /* Perform reachability analysis and reclaim all unreachable nodes. */ | |
1853 | bool remove_unreachable_nodes (bool before_inlining_p, FILE *file); | |
1854 | ||
1855 | /* Optimization of function bodies might've rendered some variables as | |
1856 | unnecessary so we want to avoid these from being compiled. Re-do | |
1857 | reachability starting from variables that are either externally visible | |
1858 | or was referred from the asm output routines. */ | |
1859 | void remove_unreferenced_decls (void); | |
1860 | ||
1861 | /* Unregister a symbol NODE. */ | |
1862 | inline void unregister (symtab_node *node); | |
1863 | ||
1864 | /* Allocate new callgraph node and insert it into basic data structures. */ | |
1865 | cgraph_node *create_empty (void); | |
1866 | ||
1867 | /* Release a callgraph NODE with UID and put in to the list | |
1868 | of free nodes. */ | |
1869 | void release_symbol (cgraph_node *node, int uid); | |
1870 | ||
1871 | /* Output all variables enqueued to be assembled. */ | |
1872 | bool output_variables (void); | |
1873 | ||
3dafb85c ML |
1874 | /* Weakrefs may be associated to external decls and thus not output |
1875 | at expansion time. Emit all necessary aliases. */ | |
1876 | void output_weakrefs (void); | |
1877 | ||
1878 | /* Return first static symbol with definition. */ | |
1879 | inline symtab_node *first_symbol (void); | |
1880 | ||
1881 | /* Return first assembler symbol. */ | |
1882 | inline asm_node * | |
1883 | first_asm_symbol (void) | |
1884 | { | |
1885 | return asmnodes; | |
1886 | } | |
1887 | ||
1888 | /* Return first static symbol with definition. */ | |
1889 | inline symtab_node *first_defined_symbol (void); | |
1890 | ||
1891 | /* Return first variable. */ | |
1892 | inline varpool_node *first_variable (void); | |
1893 | ||
1894 | /* Return next variable after NODE. */ | |
1895 | inline varpool_node *next_variable (varpool_node *node); | |
1896 | ||
1897 | /* Return first static variable with initializer. */ | |
1898 | inline varpool_node *first_static_initializer (void); | |
1899 | ||
1900 | /* Return next static variable with initializer after NODE. */ | |
1901 | inline varpool_node *next_static_initializer (varpool_node *node); | |
1902 | ||
1903 | /* Return first static variable with definition. */ | |
1904 | inline varpool_node *first_defined_variable (void); | |
1905 | ||
1906 | /* Return next static variable with definition after NODE. */ | |
1907 | inline varpool_node *next_defined_variable (varpool_node *node); | |
1908 | ||
1909 | /* Return first function with body defined. */ | |
1910 | inline cgraph_node *first_defined_function (void); | |
1911 | ||
1912 | /* Return next function with body defined after NODE. */ | |
1913 | inline cgraph_node *next_defined_function (cgraph_node *node); | |
1914 | ||
1915 | /* Return first function. */ | |
1916 | inline cgraph_node *first_function (void); | |
1917 | ||
1918 | /* Return next function. */ | |
1919 | inline cgraph_node *next_function (cgraph_node *node); | |
1920 | ||
1921 | /* Return first function with body defined. */ | |
1922 | cgraph_node *first_function_with_gimple_body (void); | |
1923 | ||
1924 | /* Return next reachable static variable with initializer after NODE. */ | |
1925 | inline cgraph_node *next_function_with_gimple_body (cgraph_node *node); | |
1926 | ||
1927 | /* Register HOOK to be called with DATA on each removed edge. */ | |
1928 | cgraph_edge_hook_list *add_edge_removal_hook (cgraph_edge_hook hook, | |
1929 | void *data); | |
1930 | ||
1931 | /* Remove ENTRY from the list of hooks called on removing edges. */ | |
1932 | void remove_edge_removal_hook (cgraph_edge_hook_list *entry); | |
1933 | ||
1934 | /* Register HOOK to be called with DATA on each removed node. */ | |
1935 | cgraph_node_hook_list *add_cgraph_removal_hook (cgraph_node_hook hook, | |
1936 | void *data); | |
1937 | ||
1938 | /* Remove ENTRY from the list of hooks called on removing nodes. */ | |
1939 | void remove_cgraph_removal_hook (cgraph_node_hook_list *entry); | |
1940 | ||
1941 | /* Register HOOK to be called with DATA on each removed node. */ | |
1942 | varpool_node_hook_list *add_varpool_removal_hook (varpool_node_hook hook, | |
1943 | void *data); | |
1944 | ||
1945 | /* Remove ENTRY from the list of hooks called on removing nodes. */ | |
1946 | void remove_varpool_removal_hook (varpool_node_hook_list *entry); | |
1947 | ||
1948 | /* Register HOOK to be called with DATA on each inserted node. */ | |
1949 | cgraph_node_hook_list *add_cgraph_insertion_hook (cgraph_node_hook hook, | |
1950 | void *data); | |
1951 | ||
1952 | /* Remove ENTRY from the list of hooks called on inserted nodes. */ | |
1953 | void remove_cgraph_insertion_hook (cgraph_node_hook_list *entry); | |
1954 | ||
1955 | /* Register HOOK to be called with DATA on each inserted node. */ | |
1956 | varpool_node_hook_list *add_varpool_insertion_hook (varpool_node_hook hook, | |
1957 | void *data); | |
1958 | ||
1959 | /* Remove ENTRY from the list of hooks called on inserted nodes. */ | |
1960 | void remove_varpool_insertion_hook (varpool_node_hook_list *entry); | |
1961 | ||
1962 | /* Register HOOK to be called with DATA on each duplicated edge. */ | |
1963 | cgraph_2edge_hook_list *add_edge_duplication_hook (cgraph_2edge_hook hook, | |
1964 | void *data); | |
1965 | /* Remove ENTRY from the list of hooks called on duplicating edges. */ | |
1966 | void remove_edge_duplication_hook (cgraph_2edge_hook_list *entry); | |
1967 | ||
1968 | /* Register HOOK to be called with DATA on each duplicated node. */ | |
1969 | cgraph_2node_hook_list *add_cgraph_duplication_hook (cgraph_2node_hook hook, | |
1970 | void *data); | |
1971 | ||
1972 | /* Remove ENTRY from the list of hooks called on duplicating nodes. */ | |
1973 | void remove_cgraph_duplication_hook (cgraph_2node_hook_list *entry); | |
1974 | ||
1975 | /* Call all edge removal hooks. */ | |
1976 | void call_edge_removal_hooks (cgraph_edge *e); | |
1977 | ||
1978 | /* Call all node insertion hooks. */ | |
1979 | void call_cgraph_insertion_hooks (cgraph_node *node); | |
1980 | ||
1981 | /* Call all node removal hooks. */ | |
1982 | void call_cgraph_removal_hooks (cgraph_node *node); | |
1983 | ||
1984 | /* Call all node duplication hooks. */ | |
1985 | void call_cgraph_duplication_hooks (cgraph_node *node, cgraph_node *node2); | |
1986 | ||
1987 | /* Call all edge duplication hooks. */ | |
1988 | void call_edge_duplication_hooks (cgraph_edge *cs1, cgraph_edge *cs2); | |
1989 | ||
1990 | /* Call all node removal hooks. */ | |
1991 | void call_varpool_removal_hooks (varpool_node *node); | |
1992 | ||
1993 | /* Call all node insertion hooks. */ | |
1994 | void call_varpool_insertion_hooks (varpool_node *node); | |
1995 | ||
1996 | /* Arrange node to be first in its entry of assembler_name_hash. */ | |
1997 | void symtab_prevail_in_asm_name_hash (symtab_node *node); | |
1998 | ||
1999 | /* Initalize asm name hash unless. */ | |
2000 | void symtab_initialize_asm_name_hash (void); | |
2001 | ||
2002 | /* Set the DECL_ASSEMBLER_NAME and update symtab hashtables. */ | |
2003 | void change_decl_assembler_name (tree decl, tree name); | |
e69529cd | 2004 | |
3dafb85c ML |
2005 | int cgraph_count; |
2006 | int cgraph_max_uid; | |
2007 | ||
2008 | int edges_count; | |
2009 | int edges_max_uid; | |
2010 | ||
2011 | symtab_node* GTY(()) nodes; | |
2012 | asm_node* GTY(()) asmnodes; | |
2013 | asm_node* GTY(()) asm_last_node; | |
2014 | cgraph_node* GTY(()) free_nodes; | |
2015 | ||
2016 | /* Head of a linked list of unused (freed) call graph edges. | |
2017 | Do not GTY((delete)) this list so UIDs gets reliably recycled. */ | |
2018 | cgraph_edge * GTY(()) free_edges; | |
2019 | ||
2020 | /* The order index of the next symtab node to be created. This is | |
2021 | used so that we can sort the cgraph nodes in order by when we saw | |
2022 | them, to support -fno-toplevel-reorder. */ | |
2023 | int order; | |
2024 | ||
2025 | /* Set when whole unit has been analyzed so we can access global info. */ | |
2026 | bool global_info_ready; | |
2027 | /* What state callgraph is in right now. */ | |
2028 | enum symtab_state state; | |
2029 | /* Set when the cgraph is fully build and the basic flags are computed. */ | |
2030 | bool function_flags_ready; | |
2031 | ||
2032 | bool cpp_implicit_aliases_done; | |
2033 | ||
2034 | /* Hash table used to hold sectoons. */ | |
2a22f99c | 2035 | hash_table<section_name_hasher> *GTY(()) section_hash; |
3dafb85c ML |
2036 | |
2037 | /* Hash table used to convert assembler names into nodes. */ | |
2a22f99c | 2038 | hash_table<asmname_hasher> *assembler_name_hash; |
3dafb85c ML |
2039 | |
2040 | /* Hash table used to hold init priorities. */ | |
b086d530 | 2041 | hash_map<symtab_node *, symbol_priority_map> *init_priority_hash; |
3dafb85c ML |
2042 | |
2043 | FILE* GTY ((skip)) dump_file; | |
2044 | ||
2045 | private: | |
2046 | /* Allocate new callgraph node. */ | |
2047 | inline cgraph_node * allocate_cgraph_symbol (void); | |
2048 | ||
2049 | /* Allocate a cgraph_edge structure and fill it with data according to the | |
2050 | parameters of which only CALLEE can be NULL (when creating an indirect call | |
2051 | edge). */ | |
2052 | cgraph_edge *create_edge (cgraph_node *caller, cgraph_node *callee, | |
2053 | gimple call_stmt, gcov_type count, int freq, | |
2054 | bool indir_unknown_callee); | |
2055 | ||
2056 | /* Put the edge onto the free list. */ | |
2057 | void free_edge (cgraph_edge *e); | |
2058 | ||
2059 | /* Insert NODE to assembler name hash. */ | |
2060 | void insert_to_assembler_name_hash (symtab_node *node, bool with_clones); | |
2061 | ||
2062 | /* Remove NODE from assembler name hash. */ | |
2063 | void unlink_from_assembler_name_hash (symtab_node *node, bool with_clones); | |
2064 | ||
2065 | /* Hash asmnames ignoring the user specified marks. */ | |
2066 | static hashval_t decl_assembler_name_hash (const_tree asmname); | |
2067 | ||
2068 | /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */ | |
2069 | static bool decl_assembler_name_equal (tree decl, const_tree asmname); | |
2070 | ||
2a22f99c | 2071 | friend struct asmname_hasher; |
3dafb85c ML |
2072 | |
2073 | /* List of hooks triggered when an edge is removed. */ | |
2074 | cgraph_edge_hook_list * GTY((skip)) m_first_edge_removal_hook; | |
2075 | /* List of hooks triggem_red when a cgraph node is removed. */ | |
2076 | cgraph_node_hook_list * GTY((skip)) m_first_cgraph_removal_hook; | |
2077 | /* List of hooks triggered when an edge is duplicated. */ | |
2078 | cgraph_2edge_hook_list * GTY((skip)) m_first_edge_duplicated_hook; | |
2079 | /* List of hooks triggered when a node is duplicated. */ | |
2080 | cgraph_2node_hook_list * GTY((skip)) m_first_cgraph_duplicated_hook; | |
2081 | /* List of hooks triggered when an function is inserted. */ | |
2082 | cgraph_node_hook_list * GTY((skip)) m_first_cgraph_insertion_hook; | |
2083 | /* List of hooks triggered when an variable is inserted. */ | |
2084 | varpool_node_hook_list * GTY((skip)) m_first_varpool_insertion_hook; | |
2085 | /* List of hooks triggered when a node is removed. */ | |
2086 | varpool_node_hook_list * GTY((skip)) m_first_varpool_removal_hook; | |
2087 | }; | |
2088 | ||
2089 | extern GTY(()) symbol_table *symtab; | |
2090 | ||
2091 | extern vec<cgraph_node *> cgraph_new_nodes; | |
2aae7680 | 2092 | |
2a22f99c TS |
2093 | inline hashval_t |
2094 | asmname_hasher::hash (symtab_node *n) | |
2095 | { | |
2096 | return symbol_table::decl_assembler_name_hash | |
2097 | (DECL_ASSEMBLER_NAME (n->decl)); | |
2098 | } | |
2099 | ||
2100 | inline bool | |
2101 | asmname_hasher::equal (symtab_node *n, const_tree t) | |
2102 | { | |
2103 | return symbol_table::decl_assembler_name_equal (n->decl, t); | |
2104 | } | |
2105 | ||
2106 | extern void gt_ggc_mx (symtab_node *&); | |
2107 | ||
2108 | inline void | |
2109 | asmname_hasher::ggc_mx (symtab_node *n) | |
2110 | { | |
2111 | gt_ggc_mx (n); | |
2112 | } | |
2113 | ||
2114 | extern void gt_pch_nx (symtab_node *&); | |
2115 | ||
2116 | inline void | |
2117 | asmname_hasher::pch_nx (symtab_node *&n) | |
2118 | { | |
2119 | gt_pch_nx (n); | |
2120 | } | |
2121 | ||
2122 | inline void | |
2123 | asmname_hasher::pch_nx (symtab_node *&n, gt_pointer_operator op, void *cookie) | |
2124 | { | |
2125 | op (&n, cookie); | |
2126 | } | |
2127 | ||
1c4a429a | 2128 | /* In cgraph.c */ |
3edf64aa | 2129 | void cgraph_c_finalize (void); |
12123452 | 2130 | void release_function_body (tree); |
3dafb85c | 2131 | cgraph_indirect_call_info *cgraph_allocate_init_indirect_info (void); |
d52f5295 | 2132 | |
4b685e14 | 2133 | void cgraph_update_edges_for_call_stmt (gimple, tree, gimple); |
1bb17c21 JH |
2134 | bool cgraph_function_possibly_inlined_p (tree); |
2135 | ||
61a05df1 | 2136 | const char* cgraph_inline_failed_string (cgraph_inline_failed_t); |
1cf11770 | 2137 | cgraph_inline_failed_type_t cgraph_inline_failed_type (cgraph_inline_failed_t); |
6b02a499 | 2138 | |
be330ed4 | 2139 | bool resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution); |
4484a35a | 2140 | extern bool gimple_check_call_matching_types (gimple, tree, bool); |
9c8305f8 JH |
2141 | |
2142 | /* In cgraphunit.c */ | |
3edf64aa DM |
2143 | void cgraphunit_c_finalize (void); |
2144 | ||
3649b9b7 ST |
2145 | /* Initialize datastructures so DECL is a function in lowered gimple form. |
2146 | IN_SSA is true if the gimple is in SSA. */ | |
e70670cf | 2147 | basic_block init_lowered_empty_function (tree, bool); |
66a20fc2 JH |
2148 | |
2149 | /* In cgraphclones.c */ | |
2150 | ||
66a20fc2 | 2151 | tree clone_function_name (tree decl, const char *); |
d52f5295 | 2152 | |
d52f5295 | 2153 | void tree_function_versioning (tree, tree, vec<ipa_replace_map *, va_gc> *, |
9c8305f8 | 2154 | bool, bitmap, bool, bitmap, basic_block); |
9c8305f8 | 2155 | |
917948d3 | 2156 | /* In cgraphbuild.c */ |
9187e02d | 2157 | int compute_call_stmt_bb_frequency (tree, basic_block bb); |
9c8305f8 | 2158 | void record_references_in_initializer (tree, bool); |
917948d3 | 2159 | |
ca31b95f | 2160 | /* In ipa.c */ |
9c8305f8 | 2161 | void cgraph_build_static_cdtor (char which, tree body, int priority); |
4a444e58 | 2162 | void ipa_discover_readonly_nonaddressable_vars (void); |
ca31b95f | 2163 | |
8a4a83ed | 2164 | /* In varpool.c */ |
6a6dac52 | 2165 | tree ctor_for_folding (tree); |
68e56cc4 | 2166 | |
d52f5295 ML |
2167 | /* Return true when the symbol is real symbol, i.e. it is not inline clone |
2168 | or abstract function kept for debug info purposes only. */ | |
2169 | inline bool | |
2170 | symtab_node::real_symbol_p (void) | |
2171 | { | |
2172 | cgraph_node *cnode; | |
2173 | ||
00de328a | 2174 | if (DECL_ABSTRACT_P (decl)) |
d52f5295 ML |
2175 | return false; |
2176 | if (!is_a <cgraph_node *> (this)) | |
2177 | return true; | |
2178 | cnode = dyn_cast <cgraph_node *> (this); | |
2179 | if (cnode->global.inlined_to) | |
2180 | return false; | |
2181 | return true; | |
2182 | } | |
2183 | ||
89330618 JH |
2184 | /* Return true if DECL should have entry in symbol table if used. |
2185 | Those are functions and static & external veriables*/ | |
2186 | ||
0241e486 | 2187 | static inline bool |
89330618 JH |
2188 | decl_in_symtab_p (const_tree decl) |
2189 | { | |
2190 | return (TREE_CODE (decl) == FUNCTION_DECL | |
2191 | || (TREE_CODE (decl) == VAR_DECL | |
2192 | && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))); | |
2193 | } | |
2194 | ||
d52f5295 ML |
2195 | inline bool |
2196 | symtab_node::in_same_comdat_group_p (symtab_node *target) | |
aede2c10 | 2197 | { |
d52f5295 | 2198 | symtab_node *source = this; |
aede2c10 | 2199 | |
d52f5295 ML |
2200 | if (cgraph_node *cn = dyn_cast <cgraph_node *> (target)) |
2201 | { | |
2202 | if (cn->global.inlined_to) | |
2203 | source = cn->global.inlined_to; | |
2204 | } | |
2205 | if (cgraph_node *cn = dyn_cast <cgraph_node *> (target)) | |
2206 | { | |
2207 | if (cn->global.inlined_to) | |
2208 | target = cn->global.inlined_to; | |
2209 | } | |
2210 | ||
2211 | return source->get_comdat_group () == target->get_comdat_group (); | |
1f00098b JH |
2212 | } |
2213 | ||
d52f5295 ML |
2214 | /* Return node that alias is aliasing. */ |
2215 | ||
2216 | inline symtab_node * | |
2217 | symtab_node::get_alias_target (void) | |
1f00098b | 2218 | { |
3dafb85c | 2219 | ipa_ref *ref = NULL; |
d52f5295 | 2220 | iterate_reference (0, ref); |
d5e254e1 IE |
2221 | if (ref->use == IPA_REF_CHKP) |
2222 | iterate_reference (1, ref); | |
d52f5295 ML |
2223 | gcc_checking_assert (ref->use == IPA_REF_ALIAS); |
2224 | return ref->referred; | |
1f00098b JH |
2225 | } |
2226 | ||
d52f5295 ML |
2227 | /* Return next reachable static symbol with initializer after the node. */ |
2228 | inline symtab_node * | |
2229 | symtab_node::next_defined_symbol (void) | |
1ab24192 | 2230 | { |
d52f5295 ML |
2231 | symtab_node *node1 = next; |
2232 | ||
2233 | for (; node1; node1 = node1->next) | |
2234 | if (node1->definition) | |
2235 | return node1; | |
2236 | ||
2237 | return NULL; | |
1ab24192 JH |
2238 | } |
2239 | ||
2240 | /* Return varpool node for given symbol and check it is a function. */ | |
3dafb85c | 2241 | |
9041d2e6 ML |
2242 | inline varpool_node * |
2243 | varpool_node::get (const_tree decl) | |
1ab24192 JH |
2244 | { |
2245 | gcc_checking_assert (TREE_CODE (decl) == VAR_DECL); | |
d52f5295 | 2246 | return dyn_cast<varpool_node *> (symtab_node::get (decl)); |
1ab24192 JH |
2247 | } |
2248 | ||
3dafb85c ML |
2249 | /* Register a symbol NODE. */ |
2250 | ||
2251 | inline void | |
2252 | symbol_table::register_symbol (symtab_node *node) | |
2253 | { | |
2254 | node->next = nodes; | |
2255 | node->previous = NULL; | |
2256 | ||
2257 | if (nodes) | |
2258 | nodes->previous = node; | |
2259 | nodes = node; | |
2260 | ||
2261 | node->order = order++; | |
2262 | } | |
2263 | ||
2264 | /* Register a top-level asm statement ASM_STR. */ | |
2265 | ||
2266 | asm_node * | |
2267 | symbol_table::finalize_toplevel_asm (tree asm_str) | |
2268 | { | |
2269 | asm_node *node; | |
2270 | ||
2271 | node = ggc_cleared_alloc<asm_node> (); | |
2272 | node->asm_str = asm_str; | |
2273 | node->order = order++; | |
2274 | node->next = NULL; | |
2275 | ||
2276 | if (asmnodes == NULL) | |
2277 | asmnodes = node; | |
2278 | else | |
2279 | asm_last_node->next = node; | |
2280 | ||
2281 | asm_last_node = node; | |
2282 | return node; | |
2283 | } | |
2284 | ||
2285 | /* Unregister a symbol NODE. */ | |
2286 | inline void | |
2287 | symbol_table::unregister (symtab_node *node) | |
2288 | { | |
2289 | if (node->previous) | |
2290 | node->previous->next = node->next; | |
2291 | else | |
2292 | nodes = node->next; | |
2293 | ||
2294 | if (node->next) | |
2295 | node->next->previous = node->previous; | |
2296 | ||
2297 | node->next = NULL; | |
2298 | node->previous = NULL; | |
2299 | } | |
2300 | ||
3dafb85c ML |
2301 | /* Release a callgraph NODE with UID and put in to the list of free nodes. */ |
2302 | ||
2303 | inline void | |
2304 | symbol_table::release_symbol (cgraph_node *node, int uid) | |
2305 | { | |
2306 | cgraph_count--; | |
2307 | ||
2308 | /* Clear out the node to NULL all pointers and add the node to the free | |
2309 | list. */ | |
2310 | memset (node, 0, sizeof (*node)); | |
2311 | node->type = SYMTAB_FUNCTION; | |
2312 | node->uid = uid; | |
2313 | SET_NEXT_FREE_NODE (node, free_nodes); | |
2314 | free_nodes = node; | |
2315 | } | |
2316 | ||
2317 | /* Allocate new callgraph node. */ | |
2318 | ||
2319 | inline cgraph_node * | |
2320 | symbol_table::allocate_cgraph_symbol (void) | |
2321 | { | |
2322 | cgraph_node *node; | |
2323 | ||
2324 | if (free_nodes) | |
2325 | { | |
2326 | node = free_nodes; | |
2327 | free_nodes = NEXT_FREE_NODE (node); | |
2328 | } | |
2329 | else | |
2330 | { | |
2331 | node = ggc_cleared_alloc<cgraph_node> (); | |
2332 | node->uid = cgraph_max_uid++; | |
2333 | } | |
2334 | ||
2335 | return node; | |
2336 | } | |
2337 | ||
2338 | ||
2339 | /* Return first static symbol with definition. */ | |
2340 | inline symtab_node * | |
2341 | symbol_table::first_symbol (void) | |
2342 | { | |
2343 | return nodes; | |
2344 | } | |
2345 | ||
1ab24192 JH |
2346 | /* Walk all symbols. */ |
2347 | #define FOR_EACH_SYMBOL(node) \ | |
3dafb85c | 2348 | for ((node) = symtab->first_symbol (); (node); (node) = (node)->next) |
1f00098b | 2349 | |
d6d229c6 | 2350 | /* Return first static symbol with definition. */ |
3dafb85c ML |
2351 | inline symtab_node * |
2352 | symbol_table::first_defined_symbol (void) | |
d6d229c6 JH |
2353 | { |
2354 | symtab_node *node; | |
2355 | ||
3dafb85c | 2356 | for (node = nodes; node; node = node->next) |
d6d229c6 JH |
2357 | if (node->definition) |
2358 | return node; | |
2359 | ||
2360 | return NULL; | |
2361 | } | |
2362 | ||
d6d229c6 JH |
2363 | /* Walk all symbols with definitions in current unit. */ |
2364 | #define FOR_EACH_DEFINED_SYMBOL(node) \ | |
3dafb85c | 2365 | for ((node) = symtab->first_defined_symbol (); (node); \ |
d52f5295 | 2366 | (node) = node->next_defined_symbol ()) |
66058468 JH |
2367 | |
2368 | /* Return first variable. */ | |
3dafb85c ML |
2369 | inline varpool_node * |
2370 | symbol_table::first_variable (void) | |
66058468 | 2371 | { |
5e20cdc9 | 2372 | symtab_node *node; |
3dafb85c | 2373 | for (node = nodes; node; node = node->next) |
7de90a6c | 2374 | if (varpool_node *vnode = dyn_cast <varpool_node *> (node)) |
5d59b5e1 | 2375 | return vnode; |
66058468 JH |
2376 | return NULL; |
2377 | } | |
2378 | ||
2379 | /* Return next variable after NODE. */ | |
3dafb85c ML |
2380 | inline varpool_node * |
2381 | symbol_table::next_variable (varpool_node *node) | |
66058468 | 2382 | { |
5e20cdc9 | 2383 | symtab_node *node1 = node->next; |
67348ccc | 2384 | for (; node1; node1 = node1->next) |
7de90a6c | 2385 | if (varpool_node *vnode1 = dyn_cast <varpool_node *> (node1)) |
5d59b5e1 | 2386 | return vnode1; |
66058468 JH |
2387 | return NULL; |
2388 | } | |
2389 | /* Walk all variables. */ | |
2390 | #define FOR_EACH_VARIABLE(node) \ | |
3dafb85c | 2391 | for ((node) = symtab->first_variable (); \ |
66058468 | 2392 | (node); \ |
3dafb85c | 2393 | (node) = symtab->next_variable ((node))) |
66058468 | 2394 | |
d6d229c6 | 2395 | /* Return first static variable with initializer. */ |
3dafb85c ML |
2396 | inline varpool_node * |
2397 | symbol_table::first_static_initializer (void) | |
68e56cc4 | 2398 | { |
5e20cdc9 | 2399 | symtab_node *node; |
3dafb85c | 2400 | for (node = nodes; node; node = node->next) |
68e56cc4 | 2401 | { |
7de90a6c | 2402 | varpool_node *vnode = dyn_cast <varpool_node *> (node); |
67348ccc | 2403 | if (vnode && DECL_INITIAL (node->decl)) |
5d59b5e1 | 2404 | return vnode; |
68e56cc4 JH |
2405 | } |
2406 | return NULL; | |
2407 | } | |
2408 | ||
d6d229c6 | 2409 | /* Return next static variable with initializer after NODE. */ |
3dafb85c ML |
2410 | inline varpool_node * |
2411 | symbol_table::next_static_initializer (varpool_node *node) | |
68e56cc4 | 2412 | { |
5e20cdc9 | 2413 | symtab_node *node1 = node->next; |
67348ccc | 2414 | for (; node1; node1 = node1->next) |
68e56cc4 | 2415 | { |
7de90a6c | 2416 | varpool_node *vnode1 = dyn_cast <varpool_node *> (node1); |
67348ccc | 2417 | if (vnode1 && DECL_INITIAL (node1->decl)) |
5d59b5e1 | 2418 | return vnode1; |
68e56cc4 JH |
2419 | } |
2420 | return NULL; | |
2421 | } | |
2422 | ||
2423 | /* Walk all static variables with initializer set. */ | |
2424 | #define FOR_EACH_STATIC_INITIALIZER(node) \ | |
3dafb85c ML |
2425 | for ((node) = symtab->first_static_initializer (); (node); \ |
2426 | (node) = symtab->next_static_initializer (node)) | |
2aae7680 | 2427 | |
d6d229c6 | 2428 | /* Return first static variable with definition. */ |
3dafb85c ML |
2429 | inline varpool_node * |
2430 | symbol_table::first_defined_variable (void) | |
2aae7680 | 2431 | { |
5e20cdc9 | 2432 | symtab_node *node; |
3dafb85c | 2433 | for (node = nodes; node; node = node->next) |
2aae7680 | 2434 | { |
7de90a6c | 2435 | varpool_node *vnode = dyn_cast <varpool_node *> (node); |
67348ccc | 2436 | if (vnode && vnode->definition) |
5d59b5e1 | 2437 | return vnode; |
2aae7680 JH |
2438 | } |
2439 | return NULL; | |
2440 | } | |
2441 | ||
d6d229c6 | 2442 | /* Return next static variable with definition after NODE. */ |
3dafb85c ML |
2443 | inline varpool_node * |
2444 | symbol_table::next_defined_variable (varpool_node *node) | |
2aae7680 | 2445 | { |
5e20cdc9 | 2446 | symtab_node *node1 = node->next; |
67348ccc | 2447 | for (; node1; node1 = node1->next) |
2aae7680 | 2448 | { |
7de90a6c | 2449 | varpool_node *vnode1 = dyn_cast <varpool_node *> (node1); |
67348ccc | 2450 | if (vnode1 && vnode1->definition) |
5d59b5e1 | 2451 | return vnode1; |
2aae7680 JH |
2452 | } |
2453 | return NULL; | |
2454 | } | |
65c70e6b JH |
2455 | /* Walk all variables with definitions in current unit. */ |
2456 | #define FOR_EACH_DEFINED_VARIABLE(node) \ | |
3dafb85c ML |
2457 | for ((node) = symtab->first_defined_variable (); (node); \ |
2458 | (node) = symtab->next_defined_variable (node)) | |
68e56cc4 | 2459 | |
c47d0034 | 2460 | /* Return first function with body defined. */ |
3dafb85c ML |
2461 | inline cgraph_node * |
2462 | symbol_table::first_defined_function (void) | |
c47d0034 | 2463 | { |
5e20cdc9 | 2464 | symtab_node *node; |
3dafb85c | 2465 | for (node = nodes; node; node = node->next) |
c47d0034 | 2466 | { |
7de90a6c | 2467 | cgraph_node *cn = dyn_cast <cgraph_node *> (node); |
67348ccc | 2468 | if (cn && cn->definition) |
5d59b5e1 | 2469 | return cn; |
c47d0034 JH |
2470 | } |
2471 | return NULL; | |
2472 | } | |
2473 | ||
45896127 | 2474 | /* Return next function with body defined after NODE. */ |
3dafb85c ML |
2475 | inline cgraph_node * |
2476 | symbol_table::next_defined_function (cgraph_node *node) | |
c47d0034 | 2477 | { |
5e20cdc9 | 2478 | symtab_node *node1 = node->next; |
67348ccc | 2479 | for (; node1; node1 = node1->next) |
c47d0034 | 2480 | { |
7de90a6c | 2481 | cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1); |
67348ccc | 2482 | if (cn1 && cn1->definition) |
5d59b5e1 | 2483 | return cn1; |
c47d0034 JH |
2484 | } |
2485 | return NULL; | |
2486 | } | |
2487 | ||
2488 | /* Walk all functions with body defined. */ | |
2489 | #define FOR_EACH_DEFINED_FUNCTION(node) \ | |
3dafb85c ML |
2490 | for ((node) = symtab->first_defined_function (); (node); \ |
2491 | (node) = symtab->next_defined_function ((node))) | |
2aae7680 JH |
2492 | |
2493 | /* Return first function. */ | |
3dafb85c ML |
2494 | inline cgraph_node * |
2495 | symbol_table::first_function (void) | |
2aae7680 | 2496 | { |
5e20cdc9 | 2497 | symtab_node *node; |
3dafb85c | 2498 | for (node = nodes; node; node = node->next) |
7de90a6c | 2499 | if (cgraph_node *cn = dyn_cast <cgraph_node *> (node)) |
5d59b5e1 | 2500 | return cn; |
2aae7680 JH |
2501 | return NULL; |
2502 | } | |
2503 | ||
2504 | /* Return next function. */ | |
3dafb85c ML |
2505 | inline cgraph_node * |
2506 | symbol_table::next_function (cgraph_node *node) | |
2aae7680 | 2507 | { |
5e20cdc9 | 2508 | symtab_node *node1 = node->next; |
67348ccc | 2509 | for (; node1; node1 = node1->next) |
7de90a6c | 2510 | if (cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1)) |
5d59b5e1 | 2511 | return cn1; |
2aae7680 JH |
2512 | return NULL; |
2513 | } | |
c47d0034 JH |
2514 | |
2515 | /* Return first function with body defined. */ | |
3dafb85c ML |
2516 | inline cgraph_node * |
2517 | symbol_table::first_function_with_gimple_body (void) | |
c47d0034 | 2518 | { |
5e20cdc9 | 2519 | symtab_node *node; |
3dafb85c | 2520 | for (node = nodes; node; node = node->next) |
c47d0034 | 2521 | { |
7de90a6c | 2522 | cgraph_node *cn = dyn_cast <cgraph_node *> (node); |
d52f5295 | 2523 | if (cn && cn->has_gimple_body_p ()) |
5d59b5e1 | 2524 | return cn; |
c47d0034 JH |
2525 | } |
2526 | return NULL; | |
2527 | } | |
2528 | ||
2529 | /* Return next reachable static variable with initializer after NODE. */ | |
3dafb85c ML |
2530 | inline cgraph_node * |
2531 | symbol_table::next_function_with_gimple_body (cgraph_node *node) | |
c47d0034 | 2532 | { |
5e20cdc9 | 2533 | symtab_node *node1 = node->next; |
67348ccc | 2534 | for (; node1; node1 = node1->next) |
c47d0034 | 2535 | { |
7de90a6c | 2536 | cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1); |
d52f5295 | 2537 | if (cn1 && cn1->has_gimple_body_p ()) |
5d59b5e1 | 2538 | return cn1; |
c47d0034 JH |
2539 | } |
2540 | return NULL; | |
2541 | } | |
2542 | ||
3dafb85c ML |
2543 | /* Walk all functions. */ |
2544 | #define FOR_EACH_FUNCTION(node) \ | |
2545 | for ((node) = symtab->first_function (); (node); \ | |
2546 | (node) = symtab->next_function ((node))) | |
2547 | ||
2548 | /* Return true when callgraph node is a function with Gimple body defined | |
2549 | in current unit. Functions can also be define externally or they | |
2550 | can be thunks with no Gimple representation. | |
2551 | ||
2552 | Note that at WPA stage, the function body may not be present in memory. */ | |
2553 | ||
2554 | inline bool | |
2555 | cgraph_node::has_gimple_body_p (void) | |
2556 | { | |
2557 | return definition && !thunk.thunk_p && !alias; | |
2558 | } | |
2559 | ||
c47d0034 JH |
2560 | /* Walk all functions with body defined. */ |
2561 | #define FOR_EACH_FUNCTION_WITH_GIMPLE_BODY(node) \ | |
3dafb85c ML |
2562 | for ((node) = symtab->first_function_with_gimple_body (); (node); \ |
2563 | (node) = symtab->next_function_with_gimple_body (node)) | |
c47d0034 | 2564 | |
43d861a5 RL |
2565 | /* Create a new static variable of type TYPE. */ |
2566 | tree add_new_static_var (tree type); | |
2567 | ||
d48e9cea OR |
2568 | /* Uniquize all constants that appear in memory. |
2569 | Each constant in memory thus far output is recorded | |
2570 | in `const_desc_table'. */ | |
2571 | ||
2a22f99c | 2572 | struct GTY((for_user)) constant_descriptor_tree { |
d48e9cea OR |
2573 | /* A MEM for the constant. */ |
2574 | rtx rtl; | |
b8698a0f | 2575 | |
d48e9cea OR |
2576 | /* The value of the constant. */ |
2577 | tree value; | |
2578 | ||
2579 | /* Hash of value. Computing the hash from value each time | |
2580 | hashfn is called can't work properly, as that means recursive | |
2581 | use of the hash table during hash table expansion. */ | |
2582 | hashval_t hash; | |
2583 | }; | |
2584 | ||
d52f5295 | 2585 | /* Return true when function is only called directly or it has alias. |
b20996ff JH |
2586 | i.e. it is not externally visible, address was not taken and |
2587 | it is not used in any other non-standard way. */ | |
2588 | ||
d52f5295 ML |
2589 | inline bool |
2590 | cgraph_node::only_called_directly_or_aliased_p (void) | |
2591 | { | |
2592 | gcc_assert (!global.inlined_to); | |
2593 | return (!force_output && !address_taken | |
2594 | && !used_from_other_partition | |
2595 | && !DECL_VIRTUAL_P (decl) | |
2596 | && !DECL_STATIC_CONSTRUCTOR (decl) | |
2597 | && !DECL_STATIC_DESTRUCTOR (decl) | |
2598 | && !externally_visible); | |
b20996ff JH |
2599 | } |
2600 | ||
9041d2e6 | 2601 | /* Return true when variable can be removed from variable pool |
df7705b1 JH |
2602 | if all direct calls are eliminated. */ |
2603 | ||
9041d2e6 ML |
2604 | inline bool |
2605 | varpool_node::can_remove_if_no_refs_p (void) | |
df7705b1 | 2606 | { |
9041d2e6 | 2607 | if (DECL_EXTERNAL (decl)) |
6649df51 | 2608 | return true; |
9041d2e6 ML |
2609 | return (!force_output && !used_from_other_partition |
2610 | && ((DECL_COMDAT (decl) | |
2611 | && !forced_by_abi | |
2612 | && !used_from_object_file_p ()) | |
2613 | || !externally_visible | |
2614 | || DECL_HAS_VALUE_EXPR_P (decl))); | |
df7705b1 JH |
2615 | } |
2616 | ||
9041d2e6 | 2617 | /* Return true when all references to variable must be visible in ipa_ref_list. |
4a444e58 JH |
2618 | i.e. if the variable is not externally visible or not used in some magic |
2619 | way (asm statement or such). | |
61502ca8 | 2620 | The magic uses are all summarized in force_output flag. */ |
4a444e58 | 2621 | |
9041d2e6 ML |
2622 | inline bool |
2623 | varpool_node::all_refs_explicit_p () | |
4a444e58 | 2624 | { |
9041d2e6 ML |
2625 | return (definition |
2626 | && !externally_visible | |
2627 | && !used_from_other_partition | |
2628 | && !force_output); | |
4a444e58 JH |
2629 | } |
2630 | ||
2a22f99c TS |
2631 | struct tree_descriptor_hasher : ggc_hasher<constant_descriptor_tree *> |
2632 | { | |
2633 | static hashval_t hash (constant_descriptor_tree *); | |
2634 | static bool equal (constant_descriptor_tree *, constant_descriptor_tree *); | |
2635 | }; | |
2636 | ||
d48e9cea | 2637 | /* Constant pool accessor function. */ |
2a22f99c | 2638 | hash_table<tree_descriptor_hasher> *constant_pool_htab (void); |
fed5ae11 | 2639 | |
d52f5295 | 2640 | /* Return node that alias is aliasing. */ |
39e2db00 | 2641 | |
d52f5295 ML |
2642 | inline cgraph_node * |
2643 | cgraph_node::get_alias_target (void) | |
cd35bcf7 | 2644 | { |
d52f5295 | 2645 | return dyn_cast <cgraph_node *> (symtab_node::get_alias_target ()); |
cd35bcf7 JH |
2646 | } |
2647 | ||
9041d2e6 ML |
2648 | /* Return node that alias is aliasing. */ |
2649 | ||
2650 | inline varpool_node * | |
2651 | varpool_node::get_alias_target (void) | |
be330ed4 | 2652 | { |
9041d2e6 | 2653 | return dyn_cast <varpool_node *> (symtab_node::get_alias_target ()); |
be330ed4 JH |
2654 | } |
2655 | ||
d52f5295 ML |
2656 | /* Given function symbol, walk the alias chain to return the function node |
2657 | is alias of. Do not walk through thunks. | |
073a8998 | 2658 | When AVAILABILITY is non-NULL, get minimal availability in the chain. */ |
be330ed4 | 2659 | |
d52f5295 ML |
2660 | inline cgraph_node * |
2661 | cgraph_node::ultimate_alias_target (enum availability *availability) | |
be330ed4 | 2662 | { |
d52f5295 ML |
2663 | cgraph_node *n = dyn_cast <cgraph_node *> (symtab_node::ultimate_alias_target |
2664 | (availability)); | |
40a7fe1e | 2665 | if (!n && availability) |
39e2db00 | 2666 | *availability = AVAIL_NOT_AVAILABLE; |
e70670cf | 2667 | return n; |
be330ed4 | 2668 | } |
9041d2e6 ML |
2669 | |
2670 | /* For given variable pool node, walk the alias chain to return the function | |
2671 | the variable is alias of. Do not walk through thunks. | |
073a8998 | 2672 | When AVAILABILITY is non-NULL, get minimal availability in the chain. */ |
cd35bcf7 | 2673 | |
9041d2e6 ML |
2674 | inline varpool_node * |
2675 | varpool_node::ultimate_alias_target (availability *availability) | |
cd35bcf7 | 2676 | { |
9041d2e6 ML |
2677 | varpool_node *n = dyn_cast <varpool_node *> |
2678 | (symtab_node::ultimate_alias_target (availability)); | |
ff36fcbe | 2679 | |
40a7fe1e | 2680 | if (!n && availability) |
cd35bcf7 | 2681 | *availability = AVAIL_NOT_AVAILABLE; |
e70670cf | 2682 | return n; |
cd35bcf7 JH |
2683 | } |
2684 | ||
3dafb85c ML |
2685 | /* Return true when the edge represents a direct recursion. */ |
2686 | inline bool | |
2687 | cgraph_edge::recursive_p (void) | |
d7d1d041 | 2688 | { |
3dafb85c ML |
2689 | cgraph_node *c = callee->ultimate_alias_target (); |
2690 | if (caller->global.inlined_to) | |
2691 | return caller->global.inlined_to->decl == c->decl; | |
d7d1d041 | 2692 | else |
3dafb85c | 2693 | return caller->decl == c->decl; |
d7d1d041 | 2694 | } |
0a35513e AH |
2695 | |
2696 | /* Return true if the TM_CLONE bit is set for a given FNDECL. */ | |
2697 | static inline bool | |
2698 | decl_is_tm_clone (const_tree fndecl) | |
2699 | { | |
d52f5295 | 2700 | cgraph_node *n = cgraph_node::get (fndecl); |
0a35513e AH |
2701 | if (n) |
2702 | return n->tm_clone; | |
2703 | return false; | |
2704 | } | |
9c8305f8 JH |
2705 | |
2706 | /* Likewise indicate that a node is needed, i.e. reachable via some | |
2707 | external means. */ | |
2708 | ||
d52f5295 ML |
2709 | inline void |
2710 | cgraph_node::mark_force_output (void) | |
1f26ac87 | 2711 | { |
d52f5295 ML |
2712 | force_output = 1; |
2713 | gcc_checking_assert (!global.inlined_to); | |
1f26ac87 JM |
2714 | } |
2715 | ||
893479de AM |
2716 | /* Return true if function should be optimized for size. */ |
2717 | ||
2718 | inline bool | |
2719 | cgraph_node::optimize_for_size_p (void) | |
2720 | { | |
2721 | if (optimize_size) | |
2722 | return true; | |
2723 | if (frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED) | |
2724 | return true; | |
2725 | else | |
2726 | return false; | |
2727 | } | |
2728 | ||
f7217cde JH |
2729 | inline symtab_node * symtab_node::get_create (tree node) |
2730 | { | |
2731 | if (TREE_CODE (node) == VAR_DECL) | |
2732 | return varpool_node::get_create (node); | |
2733 | else | |
2734 | return cgraph_node::get_create (node); | |
2735 | } | |
2736 | ||
ba392339 JH |
2737 | /* Build polymorphic call context for indirect call E. */ |
2738 | ||
2739 | inline | |
2740 | ipa_polymorphic_call_context::ipa_polymorphic_call_context (cgraph_edge *e) | |
2741 | { | |
2742 | gcc_checking_assert (e->indirect_info->polymorphic); | |
2743 | *this = e->indirect_info->context; | |
2744 | } | |
2745 | ||
2746 | /* Build empty "I know nothing" context. */ | |
2747 | ||
2748 | inline | |
2749 | ipa_polymorphic_call_context::ipa_polymorphic_call_context () | |
2750 | { | |
2751 | clear_speculation (); | |
2752 | clear_outer_type (); | |
2753 | invalid = false; | |
2754 | } | |
2755 | ||
2756 | /* Make context non-speculative. */ | |
2757 | ||
2758 | inline void | |
2759 | ipa_polymorphic_call_context::clear_speculation () | |
2760 | { | |
2761 | speculative_outer_type = NULL; | |
2762 | speculative_offset = 0; | |
2763 | speculative_maybe_derived_type = false; | |
2764 | } | |
2765 | ||
6ff65dd7 MJ |
2766 | /* Produce context specifying all derrived types of OTR_TYPE. If OTR_TYPE is |
2767 | NULL, the context is set to dummy "I know nothing" setting. */ | |
ba392339 JH |
2768 | |
2769 | inline void | |
2770 | ipa_polymorphic_call_context::clear_outer_type (tree otr_type) | |
2771 | { | |
2772 | outer_type = otr_type ? TYPE_MAIN_VARIANT (otr_type) : NULL; | |
2773 | offset = 0; | |
2774 | maybe_derived_type = true; | |
2775 | maybe_in_construction = true; | |
4081ada2 | 2776 | dynamic = true; |
ba392339 | 2777 | } |
67a1b94c JH |
2778 | |
2779 | /* Adjust all offsets in contexts by OFF bits. */ | |
2780 | ||
2781 | inline void | |
2782 | ipa_polymorphic_call_context::offset_by (HOST_WIDE_INT off) | |
2783 | { | |
2784 | if (outer_type) | |
2785 | offset += off; | |
2786 | if (speculative_outer_type) | |
2787 | speculative_offset += off; | |
2788 | } | |
2789 | ||
2790 | /* Return TRUE if context is fully useless. */ | |
2791 | ||
2792 | inline bool | |
2793 | ipa_polymorphic_call_context::useless_p () const | |
2794 | { | |
2795 | return (!outer_type && !speculative_outer_type); | |
2796 | } | |
d5e254e1 IE |
2797 | |
2798 | /* Return true if NODE is local. Instrumentation clones are counted as local | |
2799 | only when original function is local. */ | |
2800 | ||
2801 | static inline bool | |
2802 | cgraph_local_p (cgraph_node *node) | |
2803 | { | |
2804 | if (!node->instrumentation_clone || !node->instrumented_version) | |
2805 | return node->local.local; | |
2806 | ||
2807 | return node->local.local && node->instrumented_version->local.local; | |
2808 | } | |
2809 | ||
1c4a429a | 2810 | #endif /* GCC_CGRAPH_H */ |