]>
Commit | Line | Data |
---|---|---|
1c4a429a | 1 | /* Callgraph handling code. |
8d9254fc | 2 | Copyright (C) 2003-2020 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 | |
3995f3a2 | 24 | #include "profile-count.h" |
f0889939 AM |
25 | #include "ipa-ref.h" |
26 | #include "plugin-api.h" | |
ff6686d2 | 27 | #include "ipa-param-manipulation.h" |
f0889939 | 28 | |
efd9eb29 TV |
29 | extern void debuginfo_early_init (void); |
30 | extern void debuginfo_init (void); | |
31 | extern void debuginfo_fini (void); | |
32 | extern void debuginfo_start (void); | |
33 | extern void debuginfo_stop (void); | |
34 | extern void debuginfo_early_start (void); | |
35 | extern void debuginfo_early_stop (void); | |
36 | ||
f0889939 AM |
37 | class ipa_opt_pass_d; |
38 | typedef ipa_opt_pass_d *ipa_opt_pass; | |
1f00098b JH |
39 | |
40 | /* Symbol table consists of functions and variables. | |
e70670cf | 41 | TODO: add labels and CONST_DECLs. */ |
1f00098b JH |
42 | enum symtab_type |
43 | { | |
960bfb69 | 44 | SYMTAB_SYMBOL, |
1f00098b JH |
45 | SYMTAB_FUNCTION, |
46 | SYMTAB_VARIABLE | |
47 | }; | |
48 | ||
f961457f JH |
49 | /* Section names are stored as reference counted strings in GGC safe hashtable |
50 | (to make them survive through PCH). */ | |
51 | ||
50686850 | 52 | struct GTY((for_user)) section_hash_entry |
f961457f JH |
53 | { |
54 | int ref_count; | |
67914693 | 55 | char *name; /* As long as this datastructure stays in GGC, we cannot put |
f961457f JH |
56 | string at the tail of structure of GGC dies in horrible |
57 | way */ | |
58 | }; | |
59 | ||
ca752f39 | 60 | struct section_name_hasher : ggc_ptr_hash<section_hash_entry> |
2a22f99c TS |
61 | { |
62 | typedef const char *compare_type; | |
63 | ||
64 | static hashval_t hash (section_hash_entry *); | |
65 | static bool equal (section_hash_entry *, const char *); | |
66 | }; | |
67 | ||
d52f5295 ML |
68 | enum availability |
69 | { | |
70 | /* Not yet set by cgraph_function_body_availability. */ | |
71 | AVAIL_UNSET, | |
72 | /* Function body/variable initializer is unknown. */ | |
73 | AVAIL_NOT_AVAILABLE, | |
74 | /* Function body/variable initializer is known but might be replaced | |
75 | by a different one from other compilation unit and thus needs to | |
76 | be dealt with a care. Like AVAIL_NOT_AVAILABLE it can have | |
77 | arbitrary side effects on escaping variables and functions, while | |
78 | like AVAILABLE it might access static variables. */ | |
79 | AVAIL_INTERPOSABLE, | |
80 | /* Function body/variable initializer is known and will be used in final | |
81 | program. */ | |
82 | AVAIL_AVAILABLE, | |
83 | /* Function body/variable initializer is known and all it's uses are | |
dfea3d6f JJ |
84 | explicitly visible within current unit (i.e. it's address is never taken |
85 | and it is not exported to other units). Currently used only for | |
86 | functions. */ | |
d52f5295 ML |
87 | AVAIL_LOCAL |
88 | }; | |
89 | ||
90 | /* Classification of symbols WRT partitioning. */ | |
91 | enum symbol_partitioning_class | |
92 | { | |
93 | /* External declarations are ignored by partitioning algorithms and they are | |
94 | added into the boundary later via compute_ltrans_boundary. */ | |
95 | SYMBOL_EXTERNAL, | |
dfea3d6f | 96 | /* Partitioned symbols are put into one of partitions. */ |
d52f5295 ML |
97 | SYMBOL_PARTITION, |
98 | /* Duplicated symbols (such as comdat or constant pool references) are | |
99 | copied into every node needing them via add_symbol_to_partition. */ | |
100 | SYMBOL_DUPLICATE | |
101 | }; | |
102 | ||
1f00098b JH |
103 | /* Base of all entries in the symbol table. |
104 | The symtab_node is inherited by cgraph and varpol nodes. */ | |
6c1dae73 MS |
105 | struct GTY((desc ("%h.type"), tag ("SYMTAB_SYMBOL"), |
106 | chain_next ("%h.next"), chain_prev ("%h.previous"))) | |
5e20cdc9 | 107 | symtab_node |
1f00098b | 108 | { |
a3bfa8b8 | 109 | public: |
4325656f ML |
110 | friend class symbol_table; |
111 | ||
a65d584d ML |
112 | /* Constructor. */ |
113 | explicit symtab_node (symtab_type t) | |
114 | : type (t), resolution (LDPR_UNKNOWN), definition (false), alias (false), | |
115 | transparent_alias (false), weakref (false), cpp_implicit_alias (false), | |
116 | symver (false), analyzed (false), writeonly (false), | |
117 | refuse_visibility_changes (false), externally_visible (false), | |
118 | no_reorder (false), force_output (false), forced_by_abi (false), | |
119 | unique_name (false), implicit_section (false), body_removed (false), | |
120 | used_from_other_partition (false), in_other_partition (false), | |
121 | address_taken (false), in_init_priority_hash (false), | |
122 | need_lto_streaming (false), offloadable (false), ifunc_resolver (false), | |
123 | order (false), next_sharing_asm_name (NULL), | |
124 | previous_sharing_asm_name (NULL), same_comdat_group (NULL), ref_list (), | |
125 | alias_target (NULL), lto_file_data (NULL), aux (NULL), | |
126 | x_comdat_group (NULL_TREE), x_section (NULL) | |
127 | {} | |
128 | ||
fec39fa6 TS |
129 | /* Return name. */ |
130 | const char *name () const; | |
131 | ||
464d0118 ML |
132 | /* Return dump name. */ |
133 | const char *dump_name () const; | |
134 | ||
fec39fa6 | 135 | /* Return asm name. */ |
464d0118 ML |
136 | const char *asm_name () const; |
137 | ||
138 | /* Return dump name with assembler name. */ | |
139 | const char *dump_asm_name () const; | |
fec39fa6 | 140 | |
66d62d9f HK |
141 | /* Return visibility name. */ |
142 | const char *get_visibility_string () const; | |
143 | ||
144 | /* Return type_name name. */ | |
145 | const char *get_symtab_type_string () const; | |
146 | ||
d52f5295 ML |
147 | /* Add node into symbol table. This function is not used directly, but via |
148 | cgraph/varpool node creation routines. */ | |
149 | void register_symbol (void); | |
150 | ||
151 | /* Remove symbol from symbol table. */ | |
152 | void remove (void); | |
153 | ||
154 | /* Dump symtab node to F. */ | |
155 | void dump (FILE *f); | |
156 | ||
34e64622 GB |
157 | /* Dump symtab callgraph in graphviz format. */ |
158 | void dump_graphviz (FILE *f); | |
159 | ||
d52f5295 ML |
160 | /* Dump symtab node to stderr. */ |
161 | void DEBUG_FUNCTION debug (void); | |
162 | ||
163 | /* Verify consistency of node. */ | |
164 | void DEBUG_FUNCTION verify (void); | |
165 | ||
166 | /* Return ipa reference from this symtab_node to | |
dfea3d6f | 167 | REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type |
d52f5295 | 168 | of the use and STMT the statement (if it exists). */ |
3dafb85c ML |
169 | ipa_ref *create_reference (symtab_node *referred_node, |
170 | enum ipa_ref_use use_type); | |
d52f5295 ML |
171 | |
172 | /* Return ipa reference from this symtab_node to | |
dfea3d6f | 173 | REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type |
d52f5295 | 174 | of the use and STMT the statement (if it exists). */ |
3dafb85c | 175 | ipa_ref *create_reference (symtab_node *referred_node, |
355fe088 | 176 | enum ipa_ref_use use_type, gimple *stmt); |
d52f5295 ML |
177 | |
178 | /* If VAL is a reference to a function or a variable, add a reference from | |
2d8d3ae2 | 179 | this symtab_node to the corresponding symbol table node. Return the new |
d52f5295 | 180 | reference or NULL if none was created. */ |
2d8d3ae2 | 181 | ipa_ref *maybe_create_reference (tree val, gimple *stmt); |
d52f5295 ML |
182 | |
183 | /* Clone all references from symtab NODE to this symtab_node. */ | |
184 | void clone_references (symtab_node *node); | |
185 | ||
186 | /* Remove all stmt references in non-speculative references. | |
187 | Those are not maintained during inlining & clonning. | |
188 | The exception are speculative references that are updated along | |
189 | with callgraph edges associated with them. */ | |
190 | void clone_referring (symtab_node *node); | |
191 | ||
192 | /* Clone reference REF to this symtab_node and set its stmt to STMT. */ | |
355fe088 | 193 | ipa_ref *clone_reference (ipa_ref *ref, gimple *stmt); |
d52f5295 ML |
194 | |
195 | /* Find the structure describing a reference to REFERRED_NODE | |
196 | and associated with statement STMT. */ | |
355fe088 | 197 | ipa_ref *find_reference (symtab_node *referred_node, gimple *stmt, |
3dafb85c | 198 | unsigned int lto_stmt_uid); |
d52f5295 ML |
199 | |
200 | /* Remove all references that are associated with statement STMT. */ | |
355fe088 | 201 | void remove_stmt_references (gimple *stmt); |
d52f5295 ML |
202 | |
203 | /* Remove all stmt references in non-speculative references. | |
204 | Those are not maintained during inlining & clonning. | |
205 | The exception are speculative references that are updated along | |
206 | with callgraph edges associated with them. */ | |
207 | void clear_stmts_in_references (void); | |
208 | ||
209 | /* Remove all references in ref list. */ | |
210 | void remove_all_references (void); | |
211 | ||
212 | /* Remove all referring items in ref list. */ | |
213 | void remove_all_referring (void); | |
214 | ||
215 | /* Dump references in ref list to FILE. */ | |
216 | void dump_references (FILE *file); | |
217 | ||
218 | /* Dump referring in list to FILE. */ | |
219 | void dump_referring (FILE *); | |
220 | ||
b84d4347 ML |
221 | /* Get number of references for this node. */ |
222 | inline unsigned num_references (void) | |
223 | { | |
224 | return ref_list.references ? ref_list.references->length () : 0; | |
225 | } | |
226 | ||
d52f5295 | 227 | /* Iterates I-th reference in the list, REF is also set. */ |
3dafb85c | 228 | ipa_ref *iterate_reference (unsigned i, ipa_ref *&ref); |
d52f5295 ML |
229 | |
230 | /* Iterates I-th referring item in the list, REF is also set. */ | |
3dafb85c | 231 | ipa_ref *iterate_referring (unsigned i, ipa_ref *&ref); |
d52f5295 ML |
232 | |
233 | /* Iterates I-th referring alias item in the list, REF is also set. */ | |
3dafb85c | 234 | ipa_ref *iterate_direct_aliases (unsigned i, ipa_ref *&ref); |
d52f5295 ML |
235 | |
236 | /* Return true if symtab node and TARGET represents | |
237 | semantically equivalent symbols. */ | |
238 | bool semantically_equivalent_p (symtab_node *target); | |
239 | ||
240 | /* Classify symbol symtab node for partitioning. */ | |
241 | enum symbol_partitioning_class get_partitioning_class (void); | |
242 | ||
243 | /* Return comdat group. */ | |
244 | tree get_comdat_group () | |
245 | { | |
246 | return x_comdat_group; | |
247 | } | |
248 | ||
249 | /* Return comdat group as identifier_node. */ | |
250 | tree get_comdat_group_id () | |
251 | { | |
252 | if (x_comdat_group && TREE_CODE (x_comdat_group) != IDENTIFIER_NODE) | |
253 | x_comdat_group = DECL_ASSEMBLER_NAME (x_comdat_group); | |
254 | return x_comdat_group; | |
255 | } | |
256 | ||
257 | /* Set comdat group. */ | |
258 | void set_comdat_group (tree group) | |
259 | { | |
260 | gcc_checking_assert (!group || TREE_CODE (group) == IDENTIFIER_NODE | |
261 | || DECL_P (group)); | |
262 | x_comdat_group = group; | |
263 | } | |
264 | ||
265 | /* Return section as string. */ | |
266 | const char * get_section () | |
267 | { | |
268 | if (!x_section) | |
269 | return NULL; | |
270 | return x_section->name; | |
271 | } | |
272 | ||
273 | /* Remove node from same comdat group. */ | |
274 | void remove_from_same_comdat_group (void); | |
275 | ||
276 | /* Add this symtab_node to the same comdat group that OLD is in. */ | |
277 | void add_to_same_comdat_group (symtab_node *old_node); | |
278 | ||
279 | /* Dissolve the same_comdat_group list in which NODE resides. */ | |
280 | void dissolve_same_comdat_group_list (void); | |
281 | ||
282 | /* Return true when symtab_node is known to be used from other (non-LTO) | |
283 | object file. Known only when doing LTO via linker plugin. */ | |
284 | bool used_from_object_file_p (void); | |
285 | ||
286 | /* Walk the alias chain to return the symbol NODE is alias of. | |
287 | If NODE is not an alias, return NODE. | |
f13fe18b JH |
288 | When AVAILABILITY is non-NULL, get minimal availability in the chain. |
289 | When REF is non-NULL, assume that reference happens in symbol REF | |
290 | when determining the availability. */ | |
291 | symtab_node *ultimate_alias_target (enum availability *avail = NULL, | |
292 | struct symtab_node *ref = NULL); | |
d52f5295 ML |
293 | |
294 | /* Return next reachable static symbol with initializer after NODE. */ | |
295 | inline symtab_node *next_defined_symbol (void); | |
296 | ||
297 | /* Add reference recording that symtab node is alias of TARGET. | |
71e54687 | 298 | If TRANSPARENT is true make the alias to be transparent alias. |
d52f5295 ML |
299 | The function can fail in the case of aliasing cycles; in this case |
300 | it returns false. */ | |
71e54687 | 301 | bool resolve_alias (symtab_node *target, bool transparent = false); |
d52f5295 ML |
302 | |
303 | /* C++ FE sometimes change linkage flags after producing same | |
304 | body aliases. */ | |
305 | void fixup_same_cpp_alias_visibility (symtab_node *target); | |
306 | ||
6cbde2e3 | 307 | /* Call callback on symtab node and aliases associated to this node. |
d52f5295 | 308 | When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are |
6cbde2e3 | 309 | skipped. */ |
d52f5295 | 310 | bool call_for_symbol_and_aliases (bool (*callback) (symtab_node *, void *), |
a6a543bf JH |
311 | void *data, |
312 | bool include_overwrite); | |
d52f5295 | 313 | |
67914693 | 314 | /* If node cannot be interposable by static or dynamic linker to point to |
d52f5295 ML |
315 | different definition, return this symbol. Otherwise look for alias with |
316 | such property and if none exists, introduce new one. */ | |
317 | symtab_node *noninterposable_alias (void); | |
318 | ||
319 | /* Return node that alias is aliasing. */ | |
320 | inline symtab_node *get_alias_target (void); | |
321 | ||
322 | /* Set section for symbol and its aliases. */ | |
323 | void set_section (const char *section); | |
324 | ||
325 | /* Set section, do not recurse into aliases. | |
326 | When one wants to change section of symbol and its aliases, | |
327 | use set_section. */ | |
328 | void set_section_for_node (const char *section); | |
329 | ||
330 | /* Set initialization priority to PRIORITY. */ | |
331 | void set_init_priority (priority_type priority); | |
332 | ||
333 | /* Return the initialization priority. */ | |
334 | priority_type get_init_priority (); | |
335 | ||
f13fe18b JH |
336 | /* Return availability of NODE when referenced from REF. */ |
337 | enum availability get_availability (symtab_node *ref = NULL); | |
338 | ||
f714ecf5 JH |
339 | /* During LTO stream-in this predicate can be used to check whether node |
340 | in question prevails in the linking to save some memory usage. */ | |
341 | bool prevailing_p (void); | |
342 | ||
f13fe18b JH |
343 | /* Return true if NODE binds to current definition in final executable |
344 | when referenced from REF. If REF is NULL return conservative value | |
345 | for any reference. */ | |
346 | bool binds_to_current_def_p (symtab_node *ref = NULL); | |
d52f5295 ML |
347 | |
348 | /* Make DECL local. */ | |
349 | void make_decl_local (void); | |
350 | ||
ed2a53e7 JH |
351 | /* Copy visibility from N. */ |
352 | void copy_visibility_from (symtab_node *n); | |
353 | ||
428f0c67 JH |
354 | /* Return desired alignment of the definition. This is NOT alignment useful |
355 | to access THIS, because THIS may be interposable and DECL_ALIGN should | |
356 | be used instead. It however must be guaranteed when output definition | |
357 | of THIS. */ | |
358 | unsigned int definition_alignment (); | |
359 | ||
360 | /* Return true if alignment can be increased. */ | |
361 | bool can_increase_alignment_p (); | |
362 | ||
363 | /* Increase alignment of symbol to ALIGN. */ | |
364 | void increase_alignment (unsigned int align); | |
365 | ||
d52f5295 ML |
366 | /* Return true if list contains an alias. */ |
367 | bool has_aliases_p (void); | |
368 | ||
369 | /* Return true when the symbol is real symbol, i.e. it is not inline clone | |
370 | or abstract function kept for debug info purposes only. */ | |
371 | bool real_symbol_p (void); | |
372 | ||
39aa9b23 JH |
373 | /* Return true when the symbol needs to be output to the LTO symbol table. */ |
374 | bool output_to_lto_symbol_table_p (void); | |
375 | ||
3dafb85c ML |
376 | /* Determine if symbol declaration is needed. That is, visible to something |
377 | either outside this translation unit, something magic in the system | |
378 | configury. This function is used just during symbol creation. */ | |
379 | bool needed_p (void); | |
380 | ||
c2e84327 DM |
381 | /* Return true if this symbol is a function from the C frontend specified |
382 | directly in RTL form (with "__RTL"). */ | |
383 | bool native_rtl_p () const; | |
384 | ||
3dafb85c | 385 | /* Return true when there are references to the node. */ |
d7438551 | 386 | bool referred_to_p (bool include_self = true); |
3dafb85c | 387 | |
f1703a2e JH |
388 | /* Return true if symbol can be discarded by linker from the binary. |
389 | Assume that symbol is used (so there is no need to take into account | |
390 | garbage collecting linkers) | |
391 | ||
dfea3d6f | 392 | This can happen for comdats, commons and weaks when they are prevailed |
f1703a2e | 393 | by other definition at static linking time. */ |
d52f5295 ML |
394 | inline bool |
395 | can_be_discarded_p (void) | |
396 | { | |
397 | return (DECL_EXTERNAL (decl) | |
f1703a2e JH |
398 | || ((get_comdat_group () |
399 | || DECL_COMMON (decl) | |
400 | || (DECL_SECTION_NAME (decl) && DECL_WEAK (decl))) | |
401 | && ((resolution != LDPR_PREVAILING_DEF | |
402 | && resolution != LDPR_PREVAILING_DEF_IRONLY_EXP) | |
403 | || flag_incremental_link) | |
404 | && resolution != LDPR_PREVAILING_DEF_IRONLY)); | |
d52f5295 ML |
405 | } |
406 | ||
407 | /* Return true if NODE is local to a particular COMDAT group, and must not | |
408 | be named from outside the COMDAT. This is used for C++ decloned | |
409 | constructors. */ | |
410 | inline bool comdat_local_p (void) | |
411 | { | |
412 | return (same_comdat_group && !TREE_PUBLIC (decl)); | |
413 | } | |
414 | ||
415 | /* Return true if ONE and TWO are part of the same COMDAT group. */ | |
416 | inline bool in_same_comdat_group_p (symtab_node *target); | |
417 | ||
d52f5295 ML |
418 | /* Return true if symbol is known to be nonzero. */ |
419 | bool nonzero_address (); | |
420 | ||
3cb251b7 JH |
421 | /* Return 0 if symbol is known to have different address than S2, |
422 | Return 1 if symbol is known to have same address as S2, | |
b2539e1e JH |
423 | return 2 otherwise. |
424 | ||
425 | If MEMORY_ACCESSED is true, assume that both memory pointer to THIS | |
426 | and S2 is going to be accessed. This eliminates the situations when | |
dfea3d6f | 427 | either THIS or S2 is NULL and is useful for comparing bases when deciding |
b2539e1e JH |
428 | about memory aliasing. */ |
429 | int equal_address_to (symtab_node *s2, bool memory_accessed = false); | |
3cb251b7 | 430 | |
0a7246ee JH |
431 | /* Return true if symbol's address may possibly be compared to other |
432 | symbol's address. */ | |
433 | bool address_matters_p (); | |
434 | ||
435 | /* Return true if NODE's address can be compared. This use properties | |
436 | of NODE only and does not look if the address is actually taken in | |
437 | interesting way. For that use ADDRESS_MATTERS_P instead. */ | |
438 | bool address_can_be_compared_p (void); | |
439 | ||
d52f5295 ML |
440 | /* Return symbol table node associated with DECL, if any, |
441 | and NULL otherwise. */ | |
442 | static inline symtab_node *get (const_tree decl) | |
443 | { | |
d52f5295 ML |
444 | /* Check that we are called for sane type of object - functions |
445 | and static or external variables. */ | |
446 | gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL | |
447 | || (TREE_CODE (decl) == VAR_DECL | |
448 | && (TREE_STATIC (decl) || DECL_EXTERNAL (decl) | |
449 | || in_lto_p))); | |
450 | /* Check that the mapping is sane - perhaps this check can go away, | |
451 | but at the moment frontends tends to corrupt the mapping by calling | |
452 | memcpy/memset on the tree nodes. */ | |
453 | gcc_checking_assert (!decl->decl_with_vis.symtab_node | |
454 | || decl->decl_with_vis.symtab_node->decl == decl); | |
d52f5295 ML |
455 | return decl->decl_with_vis.symtab_node; |
456 | } | |
457 | ||
f7217cde JH |
458 | /* Try to find a symtab node for declaration DECL and if it does not |
459 | exist or if it corresponds to an inline clone, create a new one. */ | |
460 | static inline symtab_node * get_create (tree node); | |
461 | ||
3dafb85c ML |
462 | /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME. |
463 | Return NULL if there's no such node. */ | |
464 | static symtab_node *get_for_asmname (const_tree asmname); | |
465 | ||
d52f5295 ML |
466 | /* Verify symbol table for internal consistency. */ |
467 | static DEBUG_FUNCTION void verify_symtab_nodes (void); | |
468 | ||
b2b29377 MM |
469 | /* Perform internal consistency checks, if they are enabled. */ |
470 | static inline void checking_verify_symtab_nodes (void); | |
471 | ||
1f00098b | 472 | /* Type of the symbol. */ |
b8dbdb12 RG |
473 | ENUM_BITFIELD (symtab_type) type : 8; |
474 | ||
475 | /* The symbols resolution. */ | |
476 | ENUM_BITFIELD (ld_plugin_symbol_resolution) resolution : 8; | |
477 | ||
e70670cf JH |
478 | /*** Flags representing the symbol type. ***/ |
479 | ||
480 | /* True when symbol corresponds to a definition in current unit. | |
3dafb85c | 481 | set via finalize_function or finalize_decl */ |
e70670cf | 482 | unsigned definition : 1; |
9041d2e6 | 483 | /* True when symbol is an alias. |
dfea3d6f | 484 | Set by assemble_alias. */ |
e70670cf | 485 | unsigned alias : 1; |
71e54687 JH |
486 | /* When true the alias is translated into its target symbol either by GCC |
487 | or assembler (it also may just be a duplicate declaration of the same | |
488 | linker name). | |
489 | ||
490 | Currently transparent aliases come in three different flavors | |
491 | - aliases having the same assembler name as their target (aka duplicated | |
492 | declarations). In this case the assembler names compare via | |
493 | assembler_names_equal_p and weakref is false | |
494 | - aliases that are renamed at a time being output to final file | |
495 | by varasm.c. For those DECL_ASSEMBLER_NAME have | |
496 | IDENTIFIER_TRANSPARENT_ALIAS set and thus also their assembler | |
497 | name must be unique. | |
dfea3d6f | 498 | Weakrefs belong to this category when we target assembler without |
71e54687 JH |
499 | .weakref directive. |
500 | - weakrefs that are renamed by assembler via .weakref directive. | |
501 | In this case the alias may or may not be definition (depending if | |
502 | target declaration was seen by the compiler), weakref is set. | |
503 | Unless we are before renaming statics, assembler names are different. | |
504 | ||
505 | Given that we now support duplicate declarations, the second option is | |
506 | redundant and will be removed. */ | |
507 | unsigned transparent_alias : 1; | |
08346abd JH |
508 | /* True when alias is a weakref. */ |
509 | unsigned weakref : 1; | |
40a7fe1e | 510 | /* C++ frontend produce same body aliases and extra name aliases for |
688010ba | 511 | virtual functions and vtables that are obviously equivalent. |
40a7fe1e | 512 | Those aliases are bit special, especially because C++ frontend |
67914693 | 513 | visibility code is so ugly it cannot get them right at first time |
40a7fe1e JH |
514 | and their visibility needs to be copied from their "masters" at |
515 | the end of parsing. */ | |
516 | unsigned cpp_implicit_alias : 1; | |
d7ddfbcb JH |
517 | /* The alias is a symbol version. */ |
518 | unsigned symver : 1; | |
e70670cf JH |
519 | /* Set once the definition was analyzed. The list of references and |
520 | other properties are built during analysis. */ | |
521 | unsigned analyzed : 1; | |
6de88c6a JH |
522 | /* Set for write-only variables. */ |
523 | unsigned writeonly : 1; | |
f7217cde JH |
524 | /* Visibility of symbol was used for further optimization; do not |
525 | permit further changes. */ | |
526 | unsigned refuse_visibility_changes : 1; | |
e70670cf JH |
527 | |
528 | /*** Visibility and linkage flags. ***/ | |
529 | ||
b8dbdb12 RG |
530 | /* Set when function is visible by other units. */ |
531 | unsigned externally_visible : 1; | |
7861b648 AK |
532 | /* Don't reorder to other symbols having this set. */ |
533 | unsigned no_reorder : 1; | |
4bcfd75c | 534 | /* The symbol will be assumed to be used in an invisible way (like |
edb983b2 | 535 | by an toplevel asm statement). */ |
b8dbdb12 | 536 | unsigned force_output : 1; |
edb983b2 JH |
537 | /* Like FORCE_OUTPUT, but in the case it is ABI requiring the symbol to be |
538 | exported. Unlike FORCE_OUTPUT this flag gets cleared to symbols promoted | |
539 | to static and it does not inhibit optimization. */ | |
540 | unsigned forced_by_abi : 1; | |
702d8703 JH |
541 | /* True when the name is known to be unique and thus it does not need mangling. */ |
542 | unsigned unique_name : 1; | |
e257a17c JH |
543 | /* Specify whether the section was set by user or by |
544 | compiler via -ffunction-sections. */ | |
545 | unsigned implicit_section : 1; | |
3d8d0043 MJ |
546 | /* True when body and other characteristics have been removed by |
547 | symtab_remove_unreachable_nodes. */ | |
548 | unsigned body_removed : 1; | |
b8dbdb12 | 549 | |
e70670cf JH |
550 | /*** WHOPR Partitioning flags. |
551 | These flags are used at ltrans stage when only part of the callgraph is | |
552 | available. ***/ | |
b8dbdb12 | 553 | |
e70670cf JH |
554 | /* Set when variable is used from other LTRANS partition. */ |
555 | unsigned used_from_other_partition : 1; | |
9041d2e6 | 556 | /* Set when function is available in the other LTRANS partition. |
e70670cf JH |
557 | During WPA output it is used to mark nodes that are present in |
558 | multiple partitions. */ | |
559 | unsigned in_other_partition : 1; | |
b8dbdb12 | 560 | |
b8dbdb12 | 561 | |
e70670cf JH |
562 | |
563 | /*** other flags. ***/ | |
564 | ||
565 | /* Set when symbol has address taken. */ | |
566 | unsigned address_taken : 1; | |
569b1784 JH |
567 | /* Set when init priority is set. */ |
568 | unsigned in_init_priority_hash : 1; | |
e70670cf | 569 | |
1f6be682 IV |
570 | /* Set when symbol needs to be streamed into LTO bytecode for LTO, or in case |
571 | of offloading, for separate compilation for a different target. */ | |
572 | unsigned need_lto_streaming : 1; | |
573 | ||
574 | /* Set when symbol can be streamed into bytecode for offloading. */ | |
575 | unsigned offloadable : 1; | |
576 | ||
aab778d3 L |
577 | /* Set when symbol is an IFUNC resolver. */ |
578 | unsigned ifunc_resolver : 1; | |
579 | ||
e70670cf JH |
580 | |
581 | /* Ordering of all symtab entries. */ | |
582 | int order; | |
583 | ||
584 | /* Declaration representing the symbol. */ | |
585 | tree decl; | |
960bfb69 | 586 | |
2aae7680 | 587 | /* Linked list of symbol table entries starting with symtab_nodes. */ |
5e20cdc9 DM |
588 | symtab_node *next; |
589 | symtab_node *previous; | |
e70670cf | 590 | |
1ab24192 | 591 | /* Linked list of symbols with the same asm name. There may be multiple |
e70670cf JH |
592 | entries for single symbol name during LTO, because symbols are renamed |
593 | only after partitioning. | |
594 | ||
595 | Because inline clones are kept in the assembler name has, they also produce | |
596 | duplicate entries. | |
597 | ||
598 | There are also several long standing bugs where frontends and builtin | |
599 | code produce duplicated decls. */ | |
5e20cdc9 DM |
600 | symtab_node *next_sharing_asm_name; |
601 | symtab_node *previous_sharing_asm_name; | |
2aae7680 | 602 | |
d52f5295 ML |
603 | /* Circular list of nodes in the same comdat group if non-NULL. */ |
604 | symtab_node *same_comdat_group; | |
e55637b7 | 605 | |
e70670cf | 606 | /* Vectors of referring and referenced entities. */ |
3dafb85c | 607 | ipa_ref_list ref_list; |
e70670cf | 608 | |
40a7fe1e JH |
609 | /* Alias target. May be either DECL pointer or ASSEMBLER_NAME pointer |
610 | depending to what was known to frontend on the creation time. | |
611 | Once alias is resolved, this pointer become NULL. */ | |
612 | tree alias_target; | |
613 | ||
e70670cf JH |
614 | /* File stream where this node is being written to. */ |
615 | struct lto_file_decl_data * lto_file_data; | |
616 | ||
960bfb69 | 617 | PTR GTY ((skip)) aux; |
aede2c10 JH |
618 | |
619 | /* Comdat group the symbol is in. Can be private if GGC allowed that. */ | |
f961457f | 620 | tree x_comdat_group; |
24d047a3 JH |
621 | |
622 | /* Section name. Again can be private, if allowed. */ | |
f961457f | 623 | section_hash_entry *x_section; |
e257a17c | 624 | |
d52f5295 ML |
625 | protected: |
626 | /* Dump base fields of symtab nodes to F. Not to be used directly. */ | |
627 | void dump_base (FILE *); | |
569b1784 | 628 | |
d52f5295 ML |
629 | /* Verify common part of symtab node. */ |
630 | bool DEBUG_FUNCTION verify_base (void); | |
89330618 | 631 | |
d52f5295 ML |
632 | /* Remove node from symbol table. This function is not used directly, but via |
633 | cgraph/varpool node removal routines. */ | |
634 | void unregister (void); | |
635 | ||
636 | /* Return the initialization and finalization priority information for | |
637 | DECL. If there is no previous priority information, a freshly | |
638 | allocated structure is returned. */ | |
639 | struct symbol_priority_map *priority_info (void); | |
640 | ||
31de7606 JH |
641 | /* Worker for call_for_symbol_and_aliases_1. */ |
642 | bool call_for_symbol_and_aliases_1 (bool (*callback) (symtab_node *, void *), | |
643 | void *data, | |
644 | bool include_overwrite); | |
d52f5295 ML |
645 | private: |
646 | /* Worker for set_section. */ | |
647 | static bool set_section (symtab_node *n, void *s); | |
648 | ||
649 | /* Worker for symtab_resolve_alias. */ | |
650 | static bool set_implicit_section (symtab_node *n, void *); | |
651 | ||
652 | /* Worker searching noninterposable alias. */ | |
653 | static bool noninterposable_alias (symtab_node *node, void *data); | |
31de7606 JH |
654 | |
655 | /* Worker for ultimate_alias_target. */ | |
f13fe18b JH |
656 | symtab_node *ultimate_alias_target_1 (enum availability *avail = NULL, |
657 | symtab_node *ref = NULL); | |
464d0118 ML |
658 | |
659 | /* Get dump name with normal or assembly name. */ | |
660 | const char *get_dump_name (bool asm_name_p) const; | |
1f00098b | 661 | }; |
1c4a429a | 662 | |
b2b29377 MM |
663 | inline void |
664 | symtab_node::checking_verify_symtab_nodes (void) | |
665 | { | |
666 | if (flag_checking) | |
667 | symtab_node::verify_symtab_nodes (); | |
668 | } | |
669 | ||
e55637b7 | 670 | /* Walk all aliases for NODE. */ |
b51a085b BE |
671 | #define FOR_EACH_ALIAS(NODE, ALIAS) \ |
672 | for (unsigned ALIAS##_iter_ = 0; \ | |
673 | (NODE)->iterate_direct_aliases (ALIAS##_iter_, ALIAS); \ | |
674 | ALIAS##_iter_++) | |
6b02a499 | 675 | |
d7f09764 DN |
676 | /* This is the information that is put into the cgraph local structure |
677 | to recover a function. */ | |
678 | struct lto_file_decl_data; | |
679 | ||
8a4a83ed | 680 | extern const char * const cgraph_availability_names[]; |
430c6ceb | 681 | extern const char * const ld_plugin_symbol_resolution_names[]; |
714c800f | 682 | extern const char * const tls_model_names[]; |
8a4a83ed | 683 | |
a3e61d61 PMR |
684 | /* Sub-structure of cgraph_node. Holds information about thunk, used only for |
685 | same body aliases. | |
686 | ||
687 | Thunks are basically wrappers around methods which are introduced in case | |
688 | of multiple inheritance in order to adjust the value of the "this" pointer | |
689 | or of the returned value. | |
690 | ||
691 | In the case of this-adjusting thunks, each back-end can override the | |
692 | can_output_mi_thunk/output_mi_thunk target hooks to generate a minimal thunk | |
693 | (with a tail call for instance) directly as assembly. For the default hook | |
694 | or for the case where the can_output_mi_thunk hooks return false, the thunk | |
695 | is gimplified and lowered using the regular machinery. */ | |
6744a6ab JH |
696 | |
697 | struct GTY(()) cgraph_thunk_info { | |
a3e61d61 | 698 | /* Offset used to adjust "this". */ |
6744a6ab | 699 | HOST_WIDE_INT fixed_offset; |
a3e61d61 PMR |
700 | |
701 | /* Offset in the virtual table to get the offset to adjust "this". Valid iff | |
702 | VIRTUAL_OFFSET_P is true. */ | |
6744a6ab | 703 | HOST_WIDE_INT virtual_value; |
a3e61d61 | 704 | |
44662f68 EB |
705 | /* Offset from "this" to get the offset to adjust "this". Zero means: this |
706 | offset is to be ignored. */ | |
707 | HOST_WIDE_INT indirect_offset; | |
708 | ||
a3e61d61 PMR |
709 | /* Thunk target, i.e. the method that this thunk wraps. Depending on the |
710 | TARGET_USE_LOCAL_THUNK_ALIAS_P macro, this may have to be a new alias. */ | |
6744a6ab | 711 | tree alias; |
a3e61d61 PMR |
712 | |
713 | /* Nonzero for a "this" adjusting thunk and zero for a result adjusting | |
714 | thunk. */ | |
6744a6ab | 715 | bool this_adjusting; |
a3e61d61 PMR |
716 | |
717 | /* If true, this thunk is what we call a virtual thunk. In this case: | |
718 | * for this-adjusting thunks, after the FIXED_OFFSET based adjustment is | |
719 | done, add to the result the offset found in the vtable at: | |
720 | vptr + VIRTUAL_VALUE | |
e75a0b31 | 721 | * for result-adjusting thunks, the FIXED_OFFSET adjustment is done after |
a3e61d61 | 722 | the virtual one. */ |
6744a6ab | 723 | bool virtual_offset_p; |
a3e61d61 | 724 | |
a3e61d61 PMR |
725 | /* Set to true when alias node (the cgraph_node to which this struct belong) |
726 | is a thunk. Access to any other fields is invalid if this is false. */ | |
6744a6ab JH |
727 | bool thunk_p; |
728 | }; | |
729 | ||
9187e02d JH |
730 | /* Represent which DECL tree (or reference to such tree) |
731 | will be replaced by another tree while versioning. */ | |
732 | struct GTY(()) ipa_replace_map | |
733 | { | |
9187e02d JH |
734 | /* The new (replacing) tree. */ |
735 | tree new_tree; | |
922f15c2 JH |
736 | /* Parameter number to replace, when old_tree is NULL. */ |
737 | int parm_num; | |
9187e02d | 738 | }; |
9187e02d JH |
739 | |
740 | struct GTY(()) cgraph_clone_info | |
741 | { | |
ff6686d2 MJ |
742 | /* Constants discovered by IPA-CP, i.e. which parameter should be replaced |
743 | with what. */ | |
d52f5295 | 744 | vec<ipa_replace_map *, va_gc> *tree_map; |
ff6686d2 MJ |
745 | /* Parameter modification that IPA-SRA decided to perform. */ |
746 | ipa_param_adjustments *param_adjustments; | |
747 | /* Lists of dummy-decl and offset pairs representing split formal parameters | |
748 | in the caller. Offsets of all new replacements are enumerated, those | |
749 | coming from the same original parameter have the same dummy decl stored | |
750 | along with them. | |
751 | ||
752 | Dummy decls sit in call statement arguments followed by new parameter | |
753 | decls (or their SSA names) in between (caller) clone materialization and | |
754 | call redirection. Redirection then recognizes the dummy variable and | |
755 | together with the stored offsets can reconstruct what exactly the new | |
756 | parameter decls represent and can leave in place only those that the | |
757 | callee expects. */ | |
758 | vec<ipa_param_performed_split, va_gc> *performed_splits; | |
9187e02d JH |
759 | }; |
760 | ||
0136f8f0 AH |
761 | enum cgraph_simd_clone_arg_type |
762 | { | |
763 | SIMD_CLONE_ARG_TYPE_VECTOR, | |
764 | SIMD_CLONE_ARG_TYPE_UNIFORM, | |
d9a6bd32 | 765 | /* These are only for integer/pointer arguments passed by value. */ |
0136f8f0 AH |
766 | SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP, |
767 | SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP, | |
e01d41e5 | 768 | /* These 6 are only for reference type arguments or arguments passed |
d9a6bd32 JJ |
769 | by reference. */ |
770 | SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP, | |
e01d41e5 | 771 | SIMD_CLONE_ARG_TYPE_LINEAR_REF_VARIABLE_STEP, |
d9a6bd32 | 772 | SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP, |
e01d41e5 | 773 | SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_VARIABLE_STEP, |
d9a6bd32 | 774 | SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP, |
e01d41e5 | 775 | SIMD_CLONE_ARG_TYPE_LINEAR_VAL_VARIABLE_STEP, |
0136f8f0 AH |
776 | SIMD_CLONE_ARG_TYPE_MASK |
777 | }; | |
778 | ||
779 | /* Function arguments in the original function of a SIMD clone. | |
780 | Supplementary data for `struct simd_clone'. */ | |
781 | ||
782 | struct GTY(()) cgraph_simd_clone_arg { | |
783 | /* Original function argument as it originally existed in | |
784 | DECL_ARGUMENTS. */ | |
785 | tree orig_arg; | |
786 | ||
787 | /* orig_arg's function (or for extern functions type from | |
788 | TYPE_ARG_TYPES). */ | |
789 | tree orig_type; | |
790 | ||
791 | /* If argument is a vector, this holds the vector version of | |
792 | orig_arg that after adjusting the argument types will live in | |
793 | DECL_ARGUMENTS. Otherwise, this is NULL. | |
794 | ||
795 | This basically holds: | |
796 | vector(simdlen) __typeof__(orig_arg) new_arg. */ | |
797 | tree vector_arg; | |
798 | ||
799 | /* vector_arg's type (or for extern functions new vector type. */ | |
800 | tree vector_type; | |
801 | ||
802 | /* If argument is a vector, this holds the array where the simd | |
803 | argument is held while executing the simd clone function. This | |
804 | is a local variable in the cloned function. Its content is | |
805 | copied from vector_arg upon entry to the clone. | |
806 | ||
807 | This basically holds: | |
808 | __typeof__(orig_arg) simd_array[simdlen]. */ | |
809 | tree simd_array; | |
810 | ||
811 | /* A SIMD clone's argument can be either linear (constant or | |
812 | variable), uniform, or vector. */ | |
813 | enum cgraph_simd_clone_arg_type arg_type; | |
814 | ||
d9a6bd32 | 815 | /* For arg_type SIMD_CLONE_ARG_TYPE_LINEAR_*CONSTANT_STEP this is |
0136f8f0 | 816 | the constant linear step, if arg_type is |
e01d41e5 | 817 | SIMD_CLONE_ARG_TYPE_LINEAR_*VARIABLE_STEP, this is index of |
0136f8f0 AH |
818 | the uniform argument holding the step, otherwise 0. */ |
819 | HOST_WIDE_INT linear_step; | |
820 | ||
821 | /* Variable alignment if available, otherwise 0. */ | |
822 | unsigned int alignment; | |
823 | }; | |
824 | ||
825 | /* Specific data for a SIMD function clone. */ | |
826 | ||
827 | struct GTY(()) cgraph_simd_clone { | |
828 | /* Number of words in the SIMD lane associated with this clone. */ | |
829 | unsigned int simdlen; | |
830 | ||
831 | /* Number of annotated function arguments in `args'. This is | |
832 | usually the number of named arguments in FNDECL. */ | |
833 | unsigned int nargs; | |
834 | ||
835 | /* Max hardware vector size in bits for integral vectors. */ | |
836 | unsigned int vecsize_int; | |
837 | ||
838 | /* Max hardware vector size in bits for floating point vectors. */ | |
839 | unsigned int vecsize_float; | |
840 | ||
5f490f9f JJ |
841 | /* Machine mode of the mask argument(s), if they are to be passed |
842 | as bitmasks in integer argument(s). VOIDmode if masks are passed | |
843 | as vectors of characteristic type. */ | |
844 | machine_mode mask_mode; | |
845 | ||
026c3cfd | 846 | /* The mangling character for a given vector size. This is used |
0136f8f0 AH |
847 | to determine the ISA mangling bit as specified in the Intel |
848 | Vector ABI. */ | |
849 | unsigned char vecsize_mangle; | |
850 | ||
851 | /* True if this is the masked, in-branch version of the clone, | |
852 | otherwise false. */ | |
853 | unsigned int inbranch : 1; | |
854 | ||
0136f8f0 | 855 | /* Doubly linked list of SIMD clones. */ |
d52f5295 | 856 | cgraph_node *prev_clone, *next_clone; |
0136f8f0 AH |
857 | |
858 | /* Original cgraph node the SIMD clones were created for. */ | |
d52f5295 | 859 | cgraph_node *origin; |
0136f8f0 AH |
860 | |
861 | /* Annotated function arguments for the original function. */ | |
3dafb85c | 862 | cgraph_simd_clone_arg GTY((length ("%h.nargs"))) args[1]; |
0136f8f0 AH |
863 | }; |
864 | ||
d52f5295 | 865 | /* Function Multiversioning info. */ |
2a22f99c | 866 | struct GTY((for_user)) cgraph_function_version_info { |
d52f5295 ML |
867 | /* The cgraph_node for which the function version info is stored. */ |
868 | cgraph_node *this_node; | |
869 | /* Chains all the semantically identical function versions. The | |
870 | first function in this chain is the version_info node of the | |
871 | default function. */ | |
3dafb85c | 872 | cgraph_function_version_info *prev; |
d52f5295 ML |
873 | /* If this version node corresponds to a dispatcher for function |
874 | versions, this points to the version info node of the default | |
875 | function, the first node in the chain. */ | |
3dafb85c | 876 | cgraph_function_version_info *next; |
d52f5295 ML |
877 | /* If this node corresponds to a function version, this points |
878 | to the dispatcher function decl, which is the function that must | |
879 | be called to execute the right function version at run-time. | |
880 | ||
881 | If this cgraph node is a dispatcher (if dispatcher_function is | |
882 | true, in the cgraph_node struct) for function versions, this | |
883 | points to resolver function, which holds the function body of the | |
884 | dispatcher. The dispatcher decl is an alias to the resolver | |
885 | function decl. */ | |
886 | tree dispatcher_resolver; | |
887 | }; | |
888 | ||
889 | #define DEFCIFCODE(code, type, string) CIF_ ## code, | |
890 | /* Reasons for inlining failures. */ | |
891 | ||
892 | enum cgraph_inline_failed_t { | |
893 | #include "cif-code.def" | |
894 | CIF_N_REASONS | |
895 | }; | |
896 | ||
897 | enum cgraph_inline_failed_type_t | |
898 | { | |
899 | CIF_FINAL_NORMAL = 0, | |
900 | CIF_FINAL_ERROR | |
901 | }; | |
902 | ||
903 | struct cgraph_edge; | |
5fefcf92 | 904 | |
ca752f39 | 905 | struct cgraph_edge_hasher : ggc_ptr_hash<cgraph_edge> |
2a22f99c | 906 | { |
355fe088 | 907 | typedef gimple *compare_type; |
2a22f99c TS |
908 | |
909 | static hashval_t hash (cgraph_edge *); | |
355fe088 TS |
910 | static hashval_t hash (gimple *); |
911 | static bool equal (cgraph_edge *, gimple *); | |
2a22f99c TS |
912 | }; |
913 | ||
ba228239 | 914 | /* The cgraph data structure. |
e0bb17a8 | 915 | Each function decl has assigned cgraph_node listing callees and callers. */ |
1c4a429a | 916 | |
99b1c316 | 917 | struct GTY((tag ("SYMTAB_FUNCTION"))) cgraph_node : public symtab_node |
6c1dae73 | 918 | { |
4325656f ML |
919 | friend class symbol_table; |
920 | ||
a65d584d ML |
921 | /* Constructor. */ |
922 | explicit cgraph_node (int uid) | |
923 | : symtab_node (SYMTAB_FUNCTION), callees (NULL), callers (NULL), | |
924 | indirect_calls (NULL), origin (NULL), nested (NULL), next_nested (NULL), | |
925 | next_sibling_clone (NULL), prev_sibling_clone (NULL), clones (NULL), | |
926 | clone_of (NULL), call_site_hash (NULL), former_clone_of (NULL), | |
927 | simdclone (NULL), simd_clones (NULL), ipa_transforms_to_apply (vNULL), | |
928 | inlined_to (NULL), rtl (NULL), clone (), thunk (), | |
59c7b29e | 929 | count (profile_count::uninitialized ()), |
a65d584d | 930 | count_materialization_scale (REG_BR_PROB_BASE), profile_id (0), |
59c7b29e | 931 | unit_id (0), tp_first_run (0), used_as_abstract_origin (false), |
a65d584d ML |
932 | lowered (false), process (false), frequency (NODE_FREQUENCY_NORMAL), |
933 | only_called_at_startup (false), only_called_at_exit (false), | |
934 | tm_clone (false), dispatcher_function (false), calls_comdat_local (false), | |
935 | icf_merged (false), nonfreeing_fn (false), merged_comdat (false), | |
936 | merged_extern_inline (false), parallelized_function (false), | |
937 | split_part (false), indirect_call_target (false), local (false), | |
938 | versionable (false), can_change_signature (false), | |
939 | redefined_extern_inline (false), tm_may_enter_irr (false), | |
7a50e708 JJ |
940 | ipcp_clone (false), declare_variant_alt (false), |
941 | calls_declare_variant_alt (false), m_uid (uid), m_summary_id (-1) | |
a65d584d ML |
942 | {} |
943 | ||
d52f5295 ML |
944 | /* Remove the node from cgraph and all inline clones inlined into it. |
945 | Skip however removal of FORBIDDEN_NODE and return true if it needs to be | |
946 | removed. This allows to call the function from outer loop walking clone | |
947 | tree. */ | |
948 | bool remove_symbol_and_inline_clones (cgraph_node *forbidden_node = NULL); | |
949 | ||
950 | /* Record all references from cgraph_node that are taken | |
951 | in statement STMT. */ | |
355fe088 | 952 | void record_stmt_references (gimple *stmt); |
d52f5295 ML |
953 | |
954 | /* Like cgraph_set_call_stmt but walk the clone tree and update all | |
955 | clones sharing the same function body. | |
956 | When WHOLE_SPECULATIVE_EDGES is true, all three components of | |
957 | speculative edge gets updated. Otherwise we update only direct | |
958 | call. */ | |
355fe088 | 959 | void set_call_stmt_including_clones (gimple *old_stmt, gcall *new_stmt, |
d52f5295 ML |
960 | bool update_speculative = true); |
961 | ||
962 | /* Walk the alias chain to return the function cgraph_node is alias of. | |
963 | Walk through thunk, too. | |
f13fe18b JH |
964 | When AVAILABILITY is non-NULL, get minimal availability in the chain. |
965 | When REF is non-NULL, assume that reference happens in symbol REF | |
966 | when determining the availability. */ | |
967 | cgraph_node *function_symbol (enum availability *avail = NULL, | |
968 | struct symtab_node *ref = NULL); | |
d52f5295 | 969 | |
6cbde2e3 BE |
970 | /* Walk the alias chain to return the function cgraph_node is alias of. |
971 | Walk through non virtual thunks, too. Thus we return either a function | |
972 | or a virtual thunk node. | |
f13fe18b JH |
973 | When AVAILABILITY is non-NULL, get minimal availability in the chain. |
974 | When REF is non-NULL, assume that reference happens in symbol REF | |
975 | when determining the availability. */ | |
6cbde2e3 | 976 | cgraph_node *function_or_virtual_thunk_symbol |
f13fe18b JH |
977 | (enum availability *avail = NULL, |
978 | struct symtab_node *ref = NULL); | |
6cbde2e3 | 979 | |
d52f5295 ML |
980 | /* Create node representing clone of N executed COUNT times. Decrease |
981 | the execution counts from original node too. | |
982 | The new clone will have decl set to DECL that may or may not be the same | |
983 | as decl of N. | |
984 | ||
985 | When UPDATE_ORIGINAL is true, the counts are subtracted from the original | |
986 | function's profile to reflect the fact that part of execution is handled | |
987 | by node. | |
dfea3d6f | 988 | When CALL_DUPLICATION_HOOK is true, the ipa passes are acknowledged about |
d52f5295 ML |
989 | the new clone. Otherwise the caller is responsible for doing so later. |
990 | ||
991 | If the new node is being inlined into another one, NEW_INLINED_TO should be | |
992 | the outline function the new one is (even indirectly) inlined to. | |
a62bfab5 | 993 | All hooks will see this in node's inlined_to, when invoked. |
0bdad123 ML |
994 | Can be NULL if the node is not inlined. SUFFIX is string that is appended |
995 | to the original name. */ | |
1bad9c18 | 996 | cgraph_node *create_clone (tree decl, profile_count count, |
d52f5295 ML |
997 | bool update_original, |
998 | vec<cgraph_edge *> redirect_callers, | |
999 | bool call_duplication_hook, | |
3dafb85c | 1000 | cgraph_node *new_inlined_to, |
ff6686d2 MJ |
1001 | ipa_param_adjustments *param_adjustments, |
1002 | const char *suffix = NULL); | |
d52f5295 | 1003 | |
53aedcce MP |
1004 | /* Create callgraph node clone with new declaration. The actual body will be |
1005 | copied later at compilation stage. The name of the new clone will be | |
1006 | constructed from the name of the original node, SUFFIX and NUM_SUFFIX. */ | |
d52f5295 ML |
1007 | cgraph_node *create_virtual_clone (vec<cgraph_edge *> redirect_callers, |
1008 | vec<ipa_replace_map *, va_gc> *tree_map, | |
ff6686d2 MJ |
1009 | ipa_param_adjustments *param_adjustments, |
1010 | const char * suffix, unsigned num_suffix); | |
d52f5295 | 1011 | |
d0b1b67a MJ |
1012 | /* Remove the node from the tree of virtual and inline clones and make it a |
1013 | standalone node - not a clone any more. */ | |
1014 | void remove_from_clone_tree (); | |
1015 | ||
d52f5295 ML |
1016 | /* cgraph node being removed from symbol table; see if its entry can be |
1017 | replaced by other inline clone. */ | |
1018 | cgraph_node *find_replacement (void); | |
1019 | ||
1020 | /* Create a new cgraph node which is the new version of | |
1021 | callgraph node. REDIRECT_CALLERS holds the callers | |
1022 | edges which should be redirected to point to | |
1023 | NEW_VERSION. ALL the callees edges of the node | |
1024 | are cloned to the new version node. Return the new | |
1025 | version node. | |
1026 | ||
1027 | If non-NULL BLOCK_TO_COPY determine what basic blocks | |
1028 | was copied to prevent duplications of calls that are dead | |
0bdad123 ML |
1029 | in the clone. |
1030 | ||
1031 | SUFFIX is string that is appended to the original name. */ | |
d52f5295 ML |
1032 | |
1033 | cgraph_node *create_version_clone (tree new_decl, | |
1034 | vec<cgraph_edge *> redirect_callers, | |
0bdad123 ML |
1035 | bitmap bbs_to_copy, |
1036 | const char *suffix = NULL); | |
d52f5295 ML |
1037 | |
1038 | /* Perform function versioning. | |
1039 | Function versioning includes copying of the tree and | |
1040 | a callgraph update (creating a new cgraph node and updating | |
1041 | its callees and callers). | |
1042 | ||
1043 | REDIRECT_CALLERS varray includes the edges to be redirected | |
1044 | to the new version. | |
1045 | ||
1046 | TREE_MAP is a mapping of tree nodes we want to replace with | |
1047 | new ones (according to results of prior analysis). | |
1048 | ||
1049 | If non-NULL ARGS_TO_SKIP determine function parameters to remove | |
1050 | from new version. | |
1051 | If SKIP_RETURN is true, the new version will return void. | |
1052 | If non-NULL BLOCK_TO_COPY determine what basic blocks to copy. | |
1053 | If non_NULL NEW_ENTRY determine new entry BB of the clone. | |
1054 | ||
5928bc2e ML |
1055 | If TARGET_ATTRIBUTES is non-null, when creating a new declaration, |
1056 | add the attributes to DECL_ATTRIBUTES. And call valid_attribute_p | |
1057 | that will promote value of the attribute DECL_FUNCTION_SPECIFIC_TARGET | |
1058 | of the declaration. | |
1059 | ||
d52f5295 ML |
1060 | Return the new version's cgraph node. */ |
1061 | cgraph_node *create_version_clone_with_body | |
1062 | (vec<cgraph_edge *> redirect_callers, | |
ff6686d2 MJ |
1063 | vec<ipa_replace_map *, va_gc> *tree_map, |
1064 | ipa_param_adjustments *param_adjustments, | |
1065 | bitmap bbs_to_copy, basic_block new_entry_block, const char *clone_name, | |
1066 | tree target_attributes = NULL_TREE); | |
d52f5295 ML |
1067 | |
1068 | /* Insert a new cgraph_function_version_info node into cgraph_fnver_htab | |
1069 | corresponding to cgraph_node. */ | |
3dafb85c | 1070 | cgraph_function_version_info *insert_new_function_version (void); |
d52f5295 ML |
1071 | |
1072 | /* Get the cgraph_function_version_info node corresponding to node. */ | |
3dafb85c | 1073 | cgraph_function_version_info *function_version (void); |
d52f5295 ML |
1074 | |
1075 | /* Discover all functions and variables that are trivially needed, analyze | |
1076 | them as well as all functions and variables referred by them */ | |
1077 | void analyze (void); | |
1078 | ||
1079 | /* Add thunk alias into callgraph. The alias declaration is ALIAS and it | |
1080 | aliases DECL with an adjustments made into the first parameter. | |
a3e61d61 | 1081 | See comments in struct cgraph_thunk_info for detail on the parameters. */ |
d52f5295 ML |
1082 | cgraph_node * create_thunk (tree alias, tree, bool this_adjusting, |
1083 | HOST_WIDE_INT fixed_offset, | |
1084 | HOST_WIDE_INT virtual_value, | |
44662f68 | 1085 | HOST_WIDE_INT indirect_offset, |
d52f5295 ML |
1086 | tree virtual_offset, |
1087 | tree real_alias); | |
1088 | ||
1089 | ||
1090 | /* Return node that alias is aliasing. */ | |
1091 | inline cgraph_node *get_alias_target (void); | |
1092 | ||
1093 | /* Given function symbol, walk the alias chain to return the function node | |
1094 | is alias of. Do not walk through thunks. | |
f13fe18b JH |
1095 | When AVAILABILITY is non-NULL, get minimal availability in the chain. |
1096 | When REF is non-NULL, assume that reference happens in symbol REF | |
1097 | when determining the availability. */ | |
d52f5295 | 1098 | |
f13fe18b JH |
1099 | cgraph_node *ultimate_alias_target (availability *availability = NULL, |
1100 | symtab_node *ref = NULL); | |
d52f5295 ML |
1101 | |
1102 | /* Expand thunk NODE to gimple if possible. | |
1103 | When FORCE_GIMPLE_THUNK is true, gimple thunk is created and | |
1104 | no assembler is produced. | |
1105 | When OUTPUT_ASM_THUNK is true, also produce assembler for | |
1106 | thunks that are not lowered. */ | |
1107 | bool expand_thunk (bool output_asm_thunks, bool force_gimple_thunk); | |
1108 | ||
6a4bad95 MJ |
1109 | /* Call expand_thunk on all callers that are thunks and analyze those |
1110 | nodes that were expanded. */ | |
1111 | void expand_all_artificial_thunks (); | |
1112 | ||
3dafb85c ML |
1113 | /* Assemble thunks and aliases associated to node. */ |
1114 | void assemble_thunks_and_aliases (void); | |
1115 | ||
1116 | /* Expand function specified by node. */ | |
1117 | void expand (void); | |
1118 | ||
d52f5295 ML |
1119 | /* As an GCC extension we allow redefinition of the function. The |
1120 | semantics when both copies of bodies differ is not well defined. | |
1121 | We replace the old body with new body so in unit at a time mode | |
1122 | we always use new body, while in normal mode we may end up with | |
1123 | old body inlined into some functions and new body expanded and | |
1124 | inlined in others. */ | |
1125 | void reset (void); | |
1126 | ||
1127 | /* Creates a wrapper from cgraph_node to TARGET node. Thunk is used for this | |
1128 | kind of wrapper method. */ | |
1129 | void create_wrapper (cgraph_node *target); | |
1130 | ||
1131 | /* Verify cgraph nodes of the cgraph node. */ | |
1132 | void DEBUG_FUNCTION verify_node (void); | |
1133 | ||
1134 | /* Remove function from symbol table. */ | |
1135 | void remove (void); | |
1136 | ||
1137 | /* Dump call graph node to file F. */ | |
1138 | void dump (FILE *f); | |
1139 | ||
34e64622 GB |
1140 | /* Dump call graph node to file F. */ |
1141 | void dump_graphviz (FILE *f); | |
1142 | ||
d52f5295 ML |
1143 | /* Dump call graph node to stderr. */ |
1144 | void DEBUG_FUNCTION debug (void); | |
1145 | ||
1146 | /* When doing LTO, read cgraph_node's body from disk if it is not already | |
1147 | present. */ | |
70486010 JH |
1148 | bool get_untransformed_body (void); |
1149 | ||
1150 | /* Prepare function body. When doing LTO, read cgraph_node's body from disk | |
1151 | if it is not already present. When some IPA transformations are scheduled, | |
1152 | apply them. */ | |
d52f5295 ML |
1153 | bool get_body (void); |
1154 | ||
1155 | /* Release memory used to represent body of function. | |
1156 | Use this only for functions that are released before being translated to | |
1157 | target code (i.e. RTL). Functions that are compiled to RTL and beyond | |
1158 | are free'd in final.c via free_after_compilation(). */ | |
bf898b30 | 1159 | void release_body (bool keep_arguments = false); |
d52f5295 | 1160 | |
8ccda8bc | 1161 | /* Return the DECL_STRUCT_FUNCTION of the function. */ |
975d043f | 1162 | struct function *get_fun () const; |
8ccda8bc | 1163 | |
d52f5295 ML |
1164 | /* cgraph_node is no longer nested function; update cgraph accordingly. */ |
1165 | void unnest (void); | |
1166 | ||
1167 | /* Bring cgraph node local. */ | |
1168 | void make_local (void); | |
1169 | ||
1170 | /* Likewise indicate that a node is having address taken. */ | |
1171 | void mark_address_taken (void); | |
1172 | ||
dfea3d6f | 1173 | /* Set finalization priority to PRIORITY. */ |
d52f5295 ML |
1174 | void set_fini_priority (priority_type priority); |
1175 | ||
1176 | /* Return the finalization priority. */ | |
1177 | priority_type get_fini_priority (void); | |
1178 | ||
1179 | /* Create edge from a given function to CALLEE in the cgraph. */ | |
3dafb85c | 1180 | cgraph_edge *create_edge (cgraph_node *callee, |
3187c8a5 MJ |
1181 | gcall *call_stmt, profile_count count, |
1182 | bool cloning_p = false); | |
3dafb85c | 1183 | |
d52f5295 ML |
1184 | /* Create an indirect edge with a yet-undetermined callee where the call |
1185 | statement destination is a formal parameter of the caller with index | |
1186 | PARAM_INDEX. */ | |
538dd0b7 | 1187 | cgraph_edge *create_indirect_edge (gcall *call_stmt, int ecf_flags, |
1bad9c18 | 1188 | profile_count count, |
3187c8a5 | 1189 | bool cloning_p = false); |
d52f5295 ML |
1190 | |
1191 | /* Like cgraph_create_edge walk the clone tree and update all clones sharing | |
1192 | same function body. If clones already have edge for OLD_STMT; only | |
1193 | update the edge same way as cgraph_set_call_stmt_including_clones does. */ | |
3dafb85c | 1194 | void create_edge_including_clones (cgraph_node *callee, |
355fe088 | 1195 | gimple *old_stmt, gcall *stmt, |
3995f3a2 | 1196 | profile_count count, |
d52f5295 ML |
1197 | cgraph_inline_failed_t reason); |
1198 | ||
1199 | /* Return the callgraph edge representing the GIMPLE_CALL statement | |
1200 | CALL_STMT. */ | |
355fe088 | 1201 | cgraph_edge *get_edge (gimple *call_stmt); |
d52f5295 ML |
1202 | |
1203 | /* Collect all callers of cgraph_node and its aliases that are known to lead | |
4a414de8 | 1204 | to NODE (i.e. are not overwritable) and that are not thunks. */ |
d52f5295 ML |
1205 | vec<cgraph_edge *> collect_callers (void); |
1206 | ||
1207 | /* Remove all callers from the node. */ | |
1208 | void remove_callers (void); | |
1209 | ||
1210 | /* Remove all callees from the node. */ | |
1211 | void remove_callees (void); | |
1212 | ||
1213 | /* Return function availability. See cgraph.h for description of individual | |
1214 | return values. */ | |
f13fe18b | 1215 | enum availability get_availability (symtab_node *ref = NULL); |
d52f5295 ML |
1216 | |
1217 | /* Set TREE_NOTHROW on cgraph_node's decl and on aliases of the node | |
1218 | if any to NOTHROW. */ | |
a2b056a3 | 1219 | bool set_nothrow_flag (bool nothrow); |
d52f5295 | 1220 | |
0fab169b PK |
1221 | /* SET DECL_IS_MALLOC on cgraph_node's decl and on aliases of the node |
1222 | if any. */ | |
1223 | bool set_malloc_flag (bool malloc_p); | |
1224 | ||
69a4e898 JH |
1225 | /* If SET_CONST is true, mark function, aliases and thunks to be ECF_CONST. |
1226 | If SET_CONST if false, clear the flag. | |
1227 | ||
1228 | When setting the flag be careful about possible interposition and | |
dfea3d6f | 1229 | do not set the flag for functions that can be interposed and set pure |
69a4e898 JH |
1230 | flag for functions that can bind to other definition. |
1231 | ||
1232 | Return true if any change was done. */ | |
1233 | ||
1234 | bool set_const_flag (bool set_const, bool looping); | |
d52f5295 ML |
1235 | |
1236 | /* Set DECL_PURE_P on cgraph_node's decl and on aliases of the node | |
69a4e898 JH |
1237 | if any to PURE. |
1238 | ||
1239 | When setting the flag, be careful about possible interposition. | |
1240 | Return true if any change was done. */ | |
1241 | ||
1242 | bool set_pure_flag (bool pure, bool looping); | |
d52f5295 | 1243 | |
6cbde2e3 | 1244 | /* Call callback on function and aliases associated to the function. |
d52f5295 ML |
1245 | When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are |
1246 | skipped. */ | |
1247 | ||
1248 | bool call_for_symbol_and_aliases (bool (*callback) (cgraph_node *, | |
1249 | void *), | |
1250 | void *data, bool include_overwritable); | |
1251 | ||
6cbde2e3 | 1252 | /* Call callback on cgraph_node, thunks and aliases associated to NODE. |
d52f5295 | 1253 | When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are |
6cbde2e3 | 1254 | skipped. When EXCLUDE_VIRTUAL_THUNKS is true, virtual thunks are |
d52f5295 ML |
1255 | skipped. */ |
1256 | bool call_for_symbol_thunks_and_aliases (bool (*callback) (cgraph_node *node, | |
6cbde2e3 BE |
1257 | void *data), |
1258 | void *data, | |
1259 | bool include_overwritable, | |
1260 | bool exclude_virtual_thunks = false); | |
d52f5295 | 1261 | |
d52f5295 ML |
1262 | /* Likewise indicate that a node is needed, i.e. reachable via some |
1263 | external means. */ | |
1264 | inline void mark_force_output (void); | |
1265 | ||
1266 | /* Return true when function can be marked local. */ | |
1267 | bool local_p (void); | |
1268 | ||
1269 | /* Return true if cgraph_node can be made local for API change. | |
1270 | Extern inline functions and C++ COMDAT functions can be made local | |
1271 | at the expense of possible code size growth if function is used in multiple | |
1272 | compilation units. */ | |
1273 | bool can_be_local_p (void); | |
1274 | ||
67914693 | 1275 | /* Return true when cgraph_node cannot return or throw and thus |
d52f5295 ML |
1276 | it is safe to ignore its side effects for IPA analysis. */ |
1277 | bool cannot_return_p (void); | |
1278 | ||
1279 | /* Return true when function cgraph_node and all its aliases are only called | |
1280 | directly. | |
1281 | i.e. it is not externally visible, address was not taken and | |
1282 | it is not used in any other non-standard way. */ | |
1283 | bool only_called_directly_p (void); | |
1284 | ||
1285 | /* Return true when function is only called directly or it has alias. | |
1286 | i.e. it is not externally visible, address was not taken and | |
1287 | it is not used in any other non-standard way. */ | |
1288 | inline bool only_called_directly_or_aliased_p (void); | |
1289 | ||
1290 | /* Return true when function cgraph_node can be expected to be removed | |
1291 | from program when direct calls in this compilation unit are removed. | |
1292 | ||
1293 | As a special case COMDAT functions are | |
1294 | cgraph_can_remove_if_no_direct_calls_p while the are not | |
1295 | cgraph_only_called_directly_p (it is possible they are called from other | |
1296 | unit) | |
1297 | ||
1298 | This function behaves as cgraph_only_called_directly_p because eliminating | |
1299 | all uses of COMDAT function does not make it necessarily disappear from | |
1300 | the program unless we are compiling whole program or we do LTO. In this | |
1301 | case we know we win since dynamic linking will not really discard the | |
e0d514da JH |
1302 | linkonce section. |
1303 | ||
1304 | If WILL_INLINE is true, assume that function will be inlined into all the | |
1305 | direct calls. */ | |
1306 | bool will_be_removed_from_program_if_no_direct_calls_p | |
1307 | (bool will_inline = false); | |
d52f5295 ML |
1308 | |
1309 | /* Return true when function can be removed from callgraph | |
e0d514da JH |
1310 | if all direct calls and references are eliminated. The function does |
1311 | not take into account comdat groups. */ | |
d52f5295 ML |
1312 | bool can_remove_if_no_direct_calls_and_refs_p (void); |
1313 | ||
1314 | /* Return true when function cgraph_node and its aliases can be removed from | |
e0d514da JH |
1315 | callgraph if all direct calls are eliminated. |
1316 | If WILL_INLINE is true, assume that function will be inlined into all the | |
1317 | direct calls. */ | |
1318 | bool can_remove_if_no_direct_calls_p (bool will_inline = false); | |
d52f5295 ML |
1319 | |
1320 | /* Return true when callgraph node is a function with Gimple body defined | |
1321 | in current unit. Functions can also be define externally or they | |
1322 | can be thunks with no Gimple representation. | |
1323 | ||
1324 | Note that at WPA stage, the function body may not be present in memory. */ | |
1325 | inline bool has_gimple_body_p (void); | |
1326 | ||
1738b522 MJ |
1327 | /* Return true if this node represents a former, i.e. an expanded, thunk. */ |
1328 | inline bool former_thunk_p (void); | |
1329 | ||
72b3bc89 JH |
1330 | /* Check if function calls comdat local. This is used to recompute |
1331 | calls_comdat_local flag after function transformations. */ | |
1332 | bool check_calls_comdat_local_p (); | |
1333 | ||
d52f5295 ML |
1334 | /* Return true if function should be optimized for size. */ |
1335 | bool optimize_for_size_p (void); | |
1336 | ||
1337 | /* Dump the callgraph to file F. */ | |
1338 | static void dump_cgraph (FILE *f); | |
1339 | ||
1340 | /* Dump the call graph to stderr. */ | |
3dafb85c ML |
1341 | static inline |
1342 | void debug_cgraph (void) | |
d52f5295 ML |
1343 | { |
1344 | dump_cgraph (stderr); | |
1345 | } | |
1346 | ||
4325656f ML |
1347 | /* Get unique identifier of the node. */ |
1348 | inline int get_uid () | |
1349 | { | |
1350 | return m_uid; | |
1351 | } | |
1352 | ||
db30281f ML |
1353 | /* Get summary id of the node. */ |
1354 | inline int get_summary_id () | |
1355 | { | |
1356 | return m_summary_id; | |
1357 | } | |
1358 | ||
d52f5295 ML |
1359 | /* Record that DECL1 and DECL2 are semantically identical function |
1360 | versions. */ | |
1361 | static void record_function_versions (tree decl1, tree decl2); | |
1362 | ||
1363 | /* Remove the cgraph_function_version_info and cgraph_node for DECL. This | |
1364 | DECL is a duplicate declaration. */ | |
9acb4592 | 1365 | static void delete_function_version_by_decl (tree decl); |
d52f5295 ML |
1366 | |
1367 | /* Add the function FNDECL to the call graph. | |
3dafb85c | 1368 | Unlike finalize_function, this function is intended to be used |
d52f5295 ML |
1369 | by middle end and allows insertion of new function at arbitrary point |
1370 | of compilation. The function can be either in high, low or SSA form | |
1371 | GIMPLE. | |
1372 | ||
1373 | The function is assumed to be reachable and have address taken (so no | |
1374 | API breaking optimizations are performed on it). | |
1375 | ||
1376 | Main work done by this function is to enqueue the function for later | |
1377 | processing to avoid need the passes to be re-entrant. */ | |
1378 | static void add_new_function (tree fndecl, bool lowered); | |
1379 | ||
1380 | /* Return callgraph node for given symbol and check it is a function. */ | |
1381 | static inline cgraph_node *get (const_tree decl) | |
1382 | { | |
1383 | gcc_checking_assert (TREE_CODE (decl) == FUNCTION_DECL); | |
1384 | return dyn_cast <cgraph_node *> (symtab_node::get (decl)); | |
1385 | } | |
1386 | ||
3dafb85c ML |
1387 | /* DECL has been parsed. Take it, queue it, compile it at the whim of the |
1388 | logic in effect. If NO_COLLECT is true, then our caller cannot stand to | |
1389 | have the garbage collector run at the moment. We would need to either | |
1390 | create a new GC context, or just not compile right now. */ | |
1391 | static void finalize_function (tree, bool); | |
1392 | ||
d52f5295 ML |
1393 | /* Return cgraph node assigned to DECL. Create new one when needed. */ |
1394 | static cgraph_node * create (tree decl); | |
1395 | ||
d52f5295 ML |
1396 | /* Try to find a call graph node for declaration DECL and if it does not |
1397 | exist or if it corresponds to an inline clone, create a new one. */ | |
1398 | static cgraph_node * get_create (tree); | |
1399 | ||
3dafb85c | 1400 | /* Return local info for the compiled function. */ |
87f94429 | 1401 | static cgraph_node *local_info_node (tree decl); |
3dafb85c | 1402 | |
ef736163 | 1403 | /* Return RTL info for the compiled function. */ |
5a5a3bc5 | 1404 | static struct cgraph_rtl_info *rtl_info (const_tree); |
3dafb85c | 1405 | |
d52f5295 ML |
1406 | /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME. |
1407 | Return NULL if there's no such node. */ | |
1408 | static cgraph_node *get_for_asmname (tree asmname); | |
1409 | ||
1410 | /* Attempt to mark ALIAS as an alias to DECL. Return alias node if | |
1411 | successful and NULL otherwise. | |
1412 | Same body aliases are output whenever the body of DECL is output, | |
1413 | and cgraph_node::get (ALIAS) transparently | |
1414 | returns cgraph_node::get (DECL). */ | |
1415 | static cgraph_node * create_same_body_alias (tree alias, tree decl); | |
1416 | ||
d52f5295 ML |
1417 | /* Verify whole cgraph structure. */ |
1418 | static void DEBUG_FUNCTION verify_cgraph_nodes (void); | |
1419 | ||
b2b29377 MM |
1420 | /* Verify cgraph, if consistency checking is enabled. */ |
1421 | static inline void checking_verify_cgraph_nodes (void); | |
1422 | ||
d52f5295 ML |
1423 | /* Worker to bring NODE local. */ |
1424 | static bool make_local (cgraph_node *node, void *); | |
1425 | ||
1426 | /* Mark ALIAS as an alias to DECL. DECL_NODE is cgraph node representing | |
1427 | the function body is associated | |
1428 | with (not necessarily cgraph_node (DECL). */ | |
1429 | static cgraph_node *create_alias (tree alias, tree target); | |
1430 | ||
17d1bf76 ML |
1431 | /* Return true if NODE has thunk. */ |
1432 | static bool has_thunk_p (cgraph_node *node, void *); | |
1433 | ||
3dafb85c ML |
1434 | cgraph_edge *callees; |
1435 | cgraph_edge *callers; | |
e33c6cd6 MJ |
1436 | /* List of edges representing indirect calls with a yet undetermined |
1437 | callee. */ | |
3dafb85c | 1438 | cgraph_edge *indirect_calls; |
1c4a429a | 1439 | /* For nested functions points to function the node is nested in. */ |
d52f5295 | 1440 | cgraph_node *origin; |
1c4a429a | 1441 | /* Points to first nested function, if any. */ |
d52f5295 | 1442 | cgraph_node *nested; |
1c4a429a | 1443 | /* Pointer to the next function with same origin, if any. */ |
d52f5295 | 1444 | cgraph_node *next_nested; |
18c6ada9 | 1445 | /* Pointer to the next clone. */ |
d52f5295 ML |
1446 | cgraph_node *next_sibling_clone; |
1447 | cgraph_node *prev_sibling_clone; | |
1448 | cgraph_node *clones; | |
1449 | cgraph_node *clone_of; | |
70d539ce JH |
1450 | /* For functions with many calls sites it holds map from call expression |
1451 | to the edge to speed up cgraph_edge function. */ | |
2a22f99c | 1452 | hash_table<cgraph_edge_hasher> *GTY(()) call_site_hash; |
97ba0040 JH |
1453 | /* Declaration node used to be clone of. */ |
1454 | tree former_clone_of; | |
c22cacf3 | 1455 | |
0136f8f0 AH |
1456 | /* If this is a SIMD clone, this points to the SIMD specific |
1457 | information for it. */ | |
3dafb85c | 1458 | cgraph_simd_clone *simdclone; |
0136f8f0 | 1459 | /* If this function has SIMD clones, this points to the first clone. */ |
d52f5295 | 1460 | cgraph_node *simd_clones; |
0136f8f0 | 1461 | |
0e3776db JH |
1462 | /* Interprocedural passes scheduled to have their transform functions |
1463 | applied next time we execute local pass on them. We maintain it | |
1464 | per-function in order to allow IPA passes to introduce new functions. */ | |
9771b263 | 1465 | vec<ipa_opt_pass> GTY((skip)) ipa_transforms_to_apply; |
0e3776db | 1466 | |
a62bfab5 ML |
1467 | /* For inline clones this points to the function they will be |
1468 | inlined into. */ | |
1469 | cgraph_node *inlined_to; | |
1470 | ||
88f554b4 | 1471 | struct cgraph_rtl_info *rtl; |
3dafb85c ML |
1472 | cgraph_clone_info clone; |
1473 | cgraph_thunk_info thunk; | |
c22cacf3 | 1474 | |
e42922b1 | 1475 | /* Expected number of executions: calculated in profile.c. */ |
3995f3a2 | 1476 | profile_count count; |
db0bf14f JH |
1477 | /* How to scale counts at materialization time; used to merge |
1478 | LTO units with different number of profile runs. */ | |
1479 | int count_materialization_scale; | |
2fa3d31b JH |
1480 | /* ID assigned by the profiling. */ |
1481 | unsigned int profile_id; | |
b74d8dc4 JH |
1482 | /* ID of the translation unit. */ |
1483 | int unit_id; | |
59c7b29e JH |
1484 | /* Time profiler: first run of function. */ |
1485 | int tp_first_run; | |
3691626c | 1486 | |
6b20f353 DS |
1487 | /* Set when decl is an abstract function pointed to by the |
1488 | ABSTRACT_DECL_ORIGIN of a reachable function. */ | |
c0c123ef | 1489 | unsigned used_as_abstract_origin : 1; |
50674e96 | 1490 | /* Set once the function is lowered (i.e. its CFG is built). */ |
b4e19405 | 1491 | unsigned lowered : 1; |
25c84396 RH |
1492 | /* Set once the function has been instantiated and its callee |
1493 | lists created. */ | |
257eb6e3 | 1494 | unsigned process : 1; |
5fefcf92 JH |
1495 | /* How commonly executed the node is. Initialized during branch |
1496 | probabilities pass. */ | |
1497 | ENUM_BITFIELD (node_frequency) frequency : 2; | |
844db5d0 JH |
1498 | /* True when function can only be called at startup (from static ctor). */ |
1499 | unsigned only_called_at_startup : 1; | |
1500 | /* True when function can only be called at startup (from static dtor). */ | |
1501 | unsigned only_called_at_exit : 1; | |
0a35513e AH |
1502 | /* True when function is the transactional clone of a function which |
1503 | is called only from inside transactions. */ | |
1504 | /* ?? We should be able to remove this. We have enough bits in | |
1505 | cgraph to calculate it. */ | |
1506 | unsigned tm_clone : 1; | |
3649b9b7 ST |
1507 | /* True if this decl is a dispatcher for function versions. */ |
1508 | unsigned dispatcher_function : 1; | |
1f26ac87 | 1509 | /* True if this decl calls a COMDAT-local function. This is set up in |
0bceb671 | 1510 | compute_fn_summary and inline_call. */ |
1f26ac87 | 1511 | unsigned calls_comdat_local : 1; |
b84d4347 ML |
1512 | /* True if node has been created by merge operation in IPA-ICF. */ |
1513 | unsigned icf_merged: 1; | |
8413ca87 JJ |
1514 | /* True if call to node can't result in a call to free, munmap or |
1515 | other operation that could make previously non-trapping memory | |
1516 | accesses trapping. */ | |
1517 | unsigned nonfreeing_fn : 1; | |
ebc8f0bb | 1518 | /* True if there was multiple COMDAT bodies merged by lto-symtab. */ |
88636b62 | 1519 | unsigned merged_comdat : 1; |
b74d8dc4 JH |
1520 | /* True if this def was merged with extern inlines. */ |
1521 | unsigned merged_extern_inline : 1; | |
a79b7ec5 TV |
1522 | /* True if function was created to be executed in parallel. */ |
1523 | unsigned parallelized_function : 1; | |
41f669d8 JH |
1524 | /* True if function is part split out by ipa-split. */ |
1525 | unsigned split_part : 1; | |
4f4ada6a JH |
1526 | /* True if the function appears as possible target of indirect call. */ |
1527 | unsigned indirect_call_target : 1; | |
87f94429 ML |
1528 | /* Set when function is visible in current compilation unit only and |
1529 | its address is never taken. */ | |
1530 | unsigned local : 1; | |
1531 | /* False when there is something makes versioning impossible. */ | |
1532 | unsigned versionable : 1; | |
1533 | /* False when function calling convention and signature cannot be changed. | |
1534 | This is the case when __builtin_apply_args is used. */ | |
1535 | unsigned can_change_signature : 1; | |
1536 | /* True when the function has been originally extern inline, but it is | |
1537 | redefined now. */ | |
1538 | unsigned redefined_extern_inline : 1; | |
1539 | /* True if the function may enter serial irrevocable mode. */ | |
1540 | unsigned tm_may_enter_irr : 1; | |
6cf67b62 JH |
1541 | /* True if this was a clone created by ipa-cp. */ |
1542 | unsigned ipcp_clone : 1; | |
7a50e708 JJ |
1543 | /* True if this is the deferred declare variant resolution artificial |
1544 | function. */ | |
1545 | unsigned declare_variant_alt : 1; | |
1546 | /* True if the function calls declare_variant_alt functions. */ | |
1547 | unsigned calls_declare_variant_alt : 1; | |
31de7606 JH |
1548 | |
1549 | private: | |
4325656f ML |
1550 | /* Unique id of the node. */ |
1551 | int m_uid; | |
1552 | ||
db30281f ML |
1553 | /* Summary id that is recycled. */ |
1554 | int m_summary_id; | |
1555 | ||
31de7606 JH |
1556 | /* Worker for call_for_symbol_and_aliases. */ |
1557 | bool call_for_symbol_and_aliases_1 (bool (*callback) (cgraph_node *, | |
1558 | void *), | |
1559 | void *data, bool include_overwritable); | |
3649b9b7 ST |
1560 | }; |
1561 | ||
fed5ae11 DK |
1562 | /* A cgraph node set is a collection of cgraph nodes. A cgraph node |
1563 | can appear in multiple sets. */ | |
1cb1a99f | 1564 | struct cgraph_node_set_def |
fed5ae11 | 1565 | { |
b787e7a2 | 1566 | hash_map<cgraph_node *, size_t> *map; |
d52f5295 | 1567 | vec<cgraph_node *> nodes; |
fed5ae11 DK |
1568 | }; |
1569 | ||
d52f5295 ML |
1570 | typedef cgraph_node_set_def *cgraph_node_set; |
1571 | typedef struct varpool_node_set_def *varpool_node_set; | |
2942c502 | 1572 | |
99b1c316 | 1573 | struct varpool_node; |
2942c502 JH |
1574 | |
1575 | /* A varpool node set is a collection of varpool nodes. A varpool node | |
1576 | can appear in multiple sets. */ | |
1cb1a99f | 1577 | struct varpool_node_set_def |
2942c502 | 1578 | { |
b787e7a2 | 1579 | hash_map<varpool_node *, size_t> * map; |
d52f5295 | 1580 | vec<varpool_node *> nodes; |
2942c502 JH |
1581 | }; |
1582 | ||
fed5ae11 | 1583 | /* Iterator structure for cgraph node sets. */ |
84562394 | 1584 | struct cgraph_node_set_iterator |
fed5ae11 DK |
1585 | { |
1586 | cgraph_node_set set; | |
1587 | unsigned index; | |
84562394 | 1588 | }; |
fed5ae11 | 1589 | |
2942c502 | 1590 | /* Iterator structure for varpool node sets. */ |
84562394 | 1591 | struct varpool_node_set_iterator |
2942c502 JH |
1592 | { |
1593 | varpool_node_set set; | |
1594 | unsigned index; | |
84562394 | 1595 | }; |
2942c502 | 1596 | |
ba392339 JH |
1597 | /* Context of polymorphic call. It represent information about the type of |
1598 | instance that may reach the call. This is used by ipa-devirt walkers of the | |
1599 | type inheritance graph. */ | |
1600 | ||
1601 | class GTY(()) ipa_polymorphic_call_context { | |
1602 | public: | |
1603 | /* The called object appears in an object of type OUTER_TYPE | |
1604 | at offset OFFSET. When information is not 100% reliable, we | |
1605 | use SPECULATIVE_OUTER_TYPE and SPECULATIVE_OFFSET. */ | |
1606 | HOST_WIDE_INT offset; | |
1607 | HOST_WIDE_INT speculative_offset; | |
1608 | tree outer_type; | |
1609 | tree speculative_outer_type; | |
1610 | /* True if outer object may be in construction or destruction. */ | |
4081ada2 | 1611 | unsigned maybe_in_construction : 1; |
ba392339 | 1612 | /* True if outer object may be of derived type. */ |
4081ada2 | 1613 | unsigned maybe_derived_type : 1; |
ba392339 JH |
1614 | /* True if speculative outer object may be of derived type. We always |
1615 | speculate that construction does not happen. */ | |
4081ada2 | 1616 | unsigned speculative_maybe_derived_type : 1; |
ba392339 JH |
1617 | /* True if the context is invalid and all calls should be redirected |
1618 | to BUILTIN_UNREACHABLE. */ | |
4081ada2 JH |
1619 | unsigned invalid : 1; |
1620 | /* True if the outer type is dynamic. */ | |
1621 | unsigned dynamic : 1; | |
ba392339 JH |
1622 | |
1623 | /* Build empty "I know nothing" context. */ | |
1624 | ipa_polymorphic_call_context (); | |
1625 | /* Build polymorphic call context for indirect call E. */ | |
1626 | ipa_polymorphic_call_context (cgraph_edge *e); | |
1627 | /* Build polymorphic call context for IP invariant CST. | |
1628 | If specified, OTR_TYPE specify the type of polymorphic call | |
dfea3d6f | 1629 | that takes CST+OFFSET as a parameter. */ |
ba392339 JH |
1630 | ipa_polymorphic_call_context (tree cst, tree otr_type = NULL, |
1631 | HOST_WIDE_INT offset = 0); | |
1632 | /* Build context for pointer REF contained in FNDECL at statement STMT. | |
1633 | if INSTANCE is non-NULL, return pointer to the object described by | |
1634 | the context. */ | |
355fe088 | 1635 | ipa_polymorphic_call_context (tree fndecl, tree ref, gimple *stmt, |
ba392339 JH |
1636 | tree *instance = NULL); |
1637 | ||
1638 | /* Look for vtable stores or constructor calls to work out dynamic type | |
1639 | of memory location. */ | |
c628d1c3 | 1640 | bool get_dynamic_type (tree, tree, tree, gimple *, unsigned *); |
ba392339 JH |
1641 | |
1642 | /* Make context non-speculative. */ | |
1643 | void clear_speculation (); | |
1644 | ||
dfea3d6f | 1645 | /* Produce context specifying all derived types of OTR_TYPE. If OTR_TYPE is |
6ff65dd7 MJ |
1646 | NULL, the context is set to dummy "I know nothing" setting. */ |
1647 | void clear_outer_type (tree otr_type = NULL); | |
1648 | ||
ba392339 | 1649 | /* Walk container types and modify context to point to actual class |
67a1b94c JH |
1650 | containing OTR_TYPE (if non-NULL) as base class. |
1651 | Return true if resulting context is valid. | |
1652 | ||
1653 | When CONSIDER_PLACEMENT_NEW is false, reject contexts that may be made | |
5764ee3c | 1654 | valid only via allocation of new polymorphic type inside by means |
67a1b94c JH |
1655 | of placement new. |
1656 | ||
1657 | When CONSIDER_BASES is false, only look for actual fields, not base types | |
1658 | of TYPE. */ | |
1659 | bool restrict_to_inner_class (tree otr_type, | |
1660 | bool consider_placement_new = true, | |
1661 | bool consider_bases = true); | |
1662 | ||
1663 | /* Adjust all offsets in contexts by given number of bits. */ | |
1664 | void offset_by (HOST_WIDE_INT); | |
67914693 | 1665 | /* Use when we cannot track dynamic type change. This speculatively assume |
4081ada2 | 1666 | type change is not happening. */ |
f9bb202b | 1667 | void possible_dynamic_type_change (bool, tree otr_type = NULL); |
dfea3d6f JJ |
1668 | /* Assume that both THIS and a given context is valid and strengthen THIS |
1669 | if possible. Return true if any strengthening was made. | |
67a1b94c JH |
1670 | If actual type the context is being used in is known, OTR_TYPE should be |
1671 | set accordingly. This improves quality of combined result. */ | |
1672 | bool combine_with (ipa_polymorphic_call_context, tree otr_type = NULL); | |
df0d8136 | 1673 | bool meet_with (ipa_polymorphic_call_context, tree otr_type = NULL); |
67a1b94c JH |
1674 | |
1675 | /* Return TRUE if context is fully useless. */ | |
1676 | bool useless_p () const; | |
44210a96 MJ |
1677 | /* Return TRUE if this context conveys the same information as X. */ |
1678 | bool equal_to (const ipa_polymorphic_call_context &x) const; | |
ba392339 | 1679 | |
44210a96 MJ |
1680 | /* Dump human readable context to F. If NEWLINE is true, it will be |
1681 | terminated by a newline. */ | |
1682 | void dump (FILE *f, bool newline = true) const; | |
ba392339 JH |
1683 | void DEBUG_FUNCTION debug () const; |
1684 | ||
1685 | /* LTO streaming. */ | |
1686 | void stream_out (struct output_block *) const; | |
99b1c316 | 1687 | void stream_in (class lto_input_block *, class data_in *data_in); |
ba392339 JH |
1688 | |
1689 | private: | |
67a1b94c | 1690 | bool combine_speculation_with (tree, HOST_WIDE_INT, bool, tree); |
df0d8136 | 1691 | bool meet_speculation_with (tree, HOST_WIDE_INT, bool, tree); |
ba392339 JH |
1692 | void set_by_decl (tree, HOST_WIDE_INT); |
1693 | bool set_by_invariant (tree, tree, HOST_WIDE_INT); | |
df0d8136 | 1694 | bool speculation_consistent_p (tree, HOST_WIDE_INT, bool, tree) const; |
4081ada2 | 1695 | void make_speculative (tree otr_type = NULL); |
ba392339 JH |
1696 | }; |
1697 | ||
e33c6cd6 MJ |
1698 | /* Structure containing additional information about an indirect call. */ |
1699 | ||
6c1dae73 | 1700 | class GTY(()) cgraph_indirect_call_info |
e33c6cd6 | 1701 | { |
6c1dae73 | 1702 | public: |
ba392339 JH |
1703 | /* When agg_content is set, an offset where the call pointer is located |
1704 | within the aggregate. */ | |
1705 | HOST_WIDE_INT offset; | |
1706 | /* Context of the polymorphic call; use only when POLYMORPHIC flag is set. */ | |
1707 | ipa_polymorphic_call_context context; | |
b258210c MJ |
1708 | /* OBJ_TYPE_REF_TOKEN of a polymorphic call (if polymorphic is set). */ |
1709 | HOST_WIDE_INT otr_token; | |
1710 | /* Type of the object from OBJ_TYPE_REF_OBJECT. */ | |
ba392339 | 1711 | tree otr_type; |
e33c6cd6 MJ |
1712 | /* Index of the parameter that is called. */ |
1713 | int param_index; | |
5f902d76 JH |
1714 | /* ECF flags determined from the caller. */ |
1715 | int ecf_flags; | |
f1ba88b1 XHL |
1716 | |
1717 | /* Number of speculative call targets, it's less than GCOV_TOPN_VALUES. */ | |
1718 | unsigned num_speculative_call_targets : 16; | |
b258210c MJ |
1719 | |
1720 | /* Set when the call is a virtual call with the parameter being the | |
1721 | associated object pointer rather than a simple direct call. */ | |
1722 | unsigned polymorphic : 1; | |
8b7773a4 MJ |
1723 | /* Set when the call is a call of a pointer loaded from contents of an |
1724 | aggregate at offset. */ | |
1725 | unsigned agg_contents : 1; | |
c13bc3d9 MJ |
1726 | /* Set when this is a call through a member pointer. */ |
1727 | unsigned member_ptr : 1; | |
91bb9f80 MJ |
1728 | /* When the agg_contents bit is set, this one determines whether the |
1729 | destination is loaded from a parameter passed by reference. */ | |
8b7773a4 | 1730 | unsigned by_ref : 1; |
91bb9f80 MJ |
1731 | /* When the agg_contents bit is set, this one determines whether we can |
1732 | deduce from the function body that the loaded value from the reference is | |
1733 | never modified between the invocation of the function and the load | |
1734 | point. */ | |
1735 | unsigned guaranteed_unmodified : 1; | |
0127c169 JH |
1736 | /* For polymorphic calls this specify whether the virtual table pointer |
1737 | may have changed in between function entry and the call. */ | |
1738 | unsigned vptr_changed : 1; | |
e33c6cd6 MJ |
1739 | }; |
1740 | ||
6c1dae73 MS |
1741 | class GTY((chain_next ("%h.next_caller"), chain_prev ("%h.prev_caller"), |
1742 | for_user)) cgraph_edge | |
1743 | { | |
1744 | public: | |
99b1c316 | 1745 | friend struct cgraph_node; |
8b25212d | 1746 | friend class symbol_table; |
3dafb85c | 1747 | |
27c5a177 MJ |
1748 | /* Remove EDGE from the cgraph. */ |
1749 | static void remove (cgraph_edge *edge); | |
3dafb85c | 1750 | |
27c5a177 MJ |
1751 | /* Change field call_stmt of edge E to NEW_STMT. If UPDATE_SPECULATIVE and E |
1752 | is any component of speculative edge, then update all components. | |
1753 | Speculations can be resolved in the process and EDGE can be removed and | |
1754 | deallocated. Return the edge that now represents the call. */ | |
1755 | static cgraph_edge *set_call_stmt (cgraph_edge *e, gcall *new_stmt, | |
1756 | bool update_speculative = true); | |
3dafb85c ML |
1757 | |
1758 | /* Redirect callee of the edge to N. The function does not update underlying | |
1759 | call expression. */ | |
1760 | void redirect_callee (cgraph_node *n); | |
1761 | ||
6a4bad95 MJ |
1762 | /* If the edge does not lead to a thunk, simply redirect it to N. Otherwise |
1763 | create one or more equivalent thunks for N and redirect E to the first in | |
1764 | the chain. Note that it is then necessary to call | |
1765 | n->expand_all_artificial_thunks once all callers are redirected. */ | |
1766 | void redirect_callee_duplicating_thunks (cgraph_node *n); | |
1767 | ||
3dafb85c | 1768 | /* Make an indirect edge with an unknown callee an ordinary edge leading to |
27c5a177 MJ |
1769 | CALLEE. Speculations can be resolved in the process and EDGE can be |
1770 | removed and deallocated. Return the edge that now represents the | |
1771 | call. */ | |
1772 | static cgraph_edge *make_direct (cgraph_edge *edge, cgraph_node *callee); | |
3dafb85c ML |
1773 | |
1774 | /* Turn edge into speculative call calling N2. Update | |
1775 | the profile so the direct call is taken COUNT times | |
f1ba88b1 XHL |
1776 | with FREQUENCY. speculative_id is used to link direct calls with their |
1777 | corresponding IPA_REF_ADDR references when representing speculative calls. | |
845bb366 | 1778 | */ |
f1ba88b1 | 1779 | cgraph_edge *make_speculative (cgraph_node *n2, profile_count direct_count, |
845bb366 | 1780 | unsigned int speculative_id = 0); |
f1ba88b1 | 1781 | |
845bb366 JH |
1782 | /* Speculative call consists of an indirect edge and one or more |
1783 | direct edge+ref pairs. Speculative will expand to the following sequence: | |
1784 | ||
1785 | if (call_dest == target1) // reference to target1 | |
1786 | target1 (); // direct call to target1 | |
1787 | else if (call_dest == target2) // reference to targt2 | |
1788 | target2 (); // direct call to target2 | |
1789 | else | |
1790 | call_dest (); // indirect call | |
1791 | ||
1792 | Before the expansion we will have indirect call and the direct call+ref | |
1793 | pairs all linked to single statement. | |
1794 | ||
1795 | Note that ref may point to different symbol than the corresponding call | |
1796 | becuase the speculated edge may have been optimized (redirected to | |
1797 | a clone) or inlined. | |
1798 | ||
1799 | Given an edge which is part of speculative call, return the first | |
1800 | direct call edge in the speculative call sequence. | |
1801 | ||
1802 | In the example above called on any cgraph edge in the sequence it will | |
1803 | return direct call to target1. */ | |
1804 | cgraph_edge *first_speculative_call_target (); | |
1805 | ||
1806 | /* Return next speculative call target or NULL if there is none. | |
1807 | All targets are required to form an interval in the callee list. | |
1808 | ||
1809 | In example above, if called on call to target1 it will return call to | |
1810 | target2. */ | |
1811 | cgraph_edge *next_speculative_call_target () | |
1812 | { | |
1813 | cgraph_edge *e = this; | |
1814 | gcc_checking_assert (speculative && callee); | |
1815 | ||
1816 | if (e->next_callee && e->next_callee->speculative | |
1817 | && e->next_callee->call_stmt == e->call_stmt | |
1818 | && e->next_callee->lto_stmt_uid == e->lto_stmt_uid) | |
1819 | return e->next_callee; | |
1820 | return NULL; | |
1821 | } | |
1822 | ||
1823 | /* When called on any edge in the speculative call return the (unique) | |
1824 | indirect call edge in the speculative call sequence. */ | |
1825 | cgraph_edge *speculative_call_indirect_edge () | |
1826 | { | |
1827 | gcc_checking_assert (speculative); | |
1828 | if (!callee) | |
1829 | return this; | |
1830 | for (cgraph_edge *e2 = caller->indirect_calls; | |
1831 | true; e2 = e2->next_callee) | |
1832 | if (e2->speculative | |
1833 | && call_stmt == e2->call_stmt | |
1834 | && lto_stmt_uid == e2->lto_stmt_uid) | |
1835 | return e2; | |
1836 | } | |
1837 | ||
1838 | /* When called on any edge in speculative call and when given any target | |
1839 | of ref which is speculated to it returns the corresponding direct call. | |
1840 | ||
1841 | In example above if called on function target2 it will return call to | |
1842 | target2. */ | |
1843 | cgraph_edge *speculative_call_for_target (cgraph_node *); | |
1844 | ||
1845 | /* Return REF corresponding to direct call in the specualtive call | |
1846 | sequence. */ | |
1847 | ipa_ref *speculative_call_target_ref () | |
1848 | { | |
1849 | ipa_ref *ref; | |
1850 | ||
1851 | gcc_checking_assert (speculative); | |
1852 | for (unsigned int i = 0; caller->iterate_reference (i, ref); i++) | |
1853 | if (ref->speculative && ref->speculative_id == speculative_id | |
1854 | && ref->stmt == (gimple *)call_stmt | |
1855 | && ref->lto_stmt_uid == lto_stmt_uid) | |
1856 | return ref; | |
1857 | gcc_unreachable (); | |
1858 | } | |
3dafb85c | 1859 | |
27c5a177 MJ |
1860 | /* Speculative call edge turned out to be direct call to CALLEE_DECL. Remove |
1861 | the speculative call sequence and return edge representing the call, the | |
1862 | original EDGE can be removed and deallocated. It is up to caller to | |
1863 | redirect the call as appropriate. Return the edge that now represents the | |
f1ba88b1 XHL |
1864 | call. |
1865 | ||
1866 | For "speculative" indirect call that contains multiple "speculative" | |
1867 | targets (i.e. edge->indirect_info->num_speculative_call_targets > 1), | |
1868 | decrease the count and only remove current direct edge. | |
1869 | ||
1870 | If no speculative direct call left to the speculative indirect call, remove | |
1871 | the speculative of both the indirect call and corresponding direct edge. | |
1872 | ||
1873 | It is up to caller to iteratively resolve each "speculative" direct call | |
1874 | and redirect the call as appropriate. */ | |
27c5a177 MJ |
1875 | static cgraph_edge *resolve_speculation (cgraph_edge *edge, |
1876 | tree callee_decl = NULL); | |
3dafb85c ML |
1877 | |
1878 | /* If necessary, change the function declaration in the call statement | |
27c5a177 MJ |
1879 | associated with edge E so that it corresponds to the edge callee. |
1880 | Speculations can be resolved in the process and EDGE can be removed and | |
f1ba88b1 XHL |
1881 | deallocated. |
1882 | ||
1883 | The edge could be one of speculative direct call generated from speculative | |
1884 | indirect call. In this circumstance, decrease the speculative targets | |
1885 | count (i.e. num_speculative_call_targets) and redirect call stmt to the | |
1886 | corresponding i-th target. If no speculative direct call left to the | |
1887 | speculative indirect call, remove "speculative" of the indirect call and | |
1888 | also redirect stmt to it's final direct target. | |
1889 | ||
1890 | It is up to caller to iteratively transform each "speculative" | |
1891 | direct call as appropriate. */ | |
27c5a177 | 1892 | static gimple *redirect_call_stmt_to_callee (cgraph_edge *e); |
3dafb85c ML |
1893 | |
1894 | /* Create clone of edge in the node N represented | |
1895 | by CALL_EXPR the callgraph. */ | |
538dd0b7 | 1896 | cgraph_edge * clone (cgraph_node *n, gcall *call_stmt, unsigned stmt_uid, |
1bad9c18 | 1897 | profile_count num, profile_count den, |
3995f3a2 | 1898 | bool update_original); |
3dafb85c | 1899 | |
90988f77 | 1900 | /* Verify edge count and frequency. */ |
1bad9c18 | 1901 | bool verify_count (); |
90988f77 | 1902 | |
67914693 | 1903 | /* Return true when call of edge cannot lead to return from caller |
3dafb85c ML |
1904 | and thus it is safe to ignore its side effects for IPA analysis |
1905 | when computing side effects of the caller. */ | |
1906 | bool cannot_lead_to_return_p (void); | |
1907 | ||
1908 | /* Return true when the edge represents a direct recursion. */ | |
1909 | bool recursive_p (void); | |
1910 | ||
bf321336 | 1911 | /* Return true if the edge may be considered hot. */ |
3dafb85c ML |
1912 | bool maybe_hot_p (void); |
1913 | ||
8b25212d ML |
1914 | /* Get unique identifier of the edge. */ |
1915 | inline int get_uid () | |
1916 | { | |
1917 | return m_uid; | |
1918 | } | |
1919 | ||
db30281f ML |
1920 | /* Get summary id of the edge. */ |
1921 | inline int get_summary_id () | |
1922 | { | |
1923 | return m_summary_id; | |
1924 | } | |
1925 | ||
3dafb85c ML |
1926 | /* Rebuild cgraph edges for current function node. This needs to be run after |
1927 | passes that don't update the cgraph. */ | |
1928 | static unsigned int rebuild_edges (void); | |
1929 | ||
1930 | /* Rebuild cgraph references for current function node. This needs to be run | |
1931 | after passes that don't update the cgraph. */ | |
1932 | static void rebuild_references (void); | |
1933 | ||
f714ecf5 JH |
1934 | /* During LTO stream in this can be used to check whether call can possibly |
1935 | be internal to the current translation unit. */ | |
1936 | bool possibly_call_in_translation_unit_p (void); | |
1937 | ||
f1ba88b1 XHL |
1938 | /* Return num_speculative_targets of this edge. */ |
1939 | int num_speculative_call_targets_p (void); | |
1940 | ||
6009ee7b | 1941 | /* Expected number of executions: calculated in profile.c. */ |
3995f3a2 | 1942 | profile_count count; |
d52f5295 ML |
1943 | cgraph_node *caller; |
1944 | cgraph_node *callee; | |
3dafb85c ML |
1945 | cgraph_edge *prev_caller; |
1946 | cgraph_edge *next_caller; | |
1947 | cgraph_edge *prev_callee; | |
1948 | cgraph_edge *next_callee; | |
538dd0b7 | 1949 | gcall *call_stmt; |
e33c6cd6 MJ |
1950 | /* Additional information about an indirect call. Not cleared when an edge |
1951 | becomes direct. */ | |
3dafb85c | 1952 | cgraph_indirect_call_info *indirect_info; |
18c6ada9 | 1953 | PTR GTY ((skip (""))) aux; |
61a05df1 JH |
1954 | /* When equal to CIF_OK, inline this call. Otherwise, points to the |
1955 | explanation why function was not inlined. */ | |
84562394 | 1956 | enum cgraph_inline_failed_t inline_failed; |
6009ee7b MJ |
1957 | /* The stmt_uid of call_stmt. This is used by LTO to recover the call_stmt |
1958 | when the function is serialized in. */ | |
1959 | unsigned int lto_stmt_uid; | |
f1ba88b1 XHL |
1960 | /* speculative id is used to link direct calls with their corresponding |
1961 | IPA_REF_ADDR references when representing speculative calls. */ | |
1962 | unsigned int speculative_id : 16; | |
e33c6cd6 MJ |
1963 | /* Whether this edge was made direct by indirect inlining. */ |
1964 | unsigned int indirect_inlining_edge : 1; | |
1965 | /* Whether this edge describes an indirect call with an undetermined | |
1966 | callee. */ | |
1967 | unsigned int indirect_unknown_callee : 1; | |
1968 | /* Whether this edge is still a dangling */ | |
d7f09764 DN |
1969 | /* True if the corresponding CALL stmt cannot be inlined. */ |
1970 | unsigned int call_stmt_cannot_inline_p : 1; | |
2505c5ed JH |
1971 | /* Can this call throw externally? */ |
1972 | unsigned int can_throw_external : 1; | |
042ae7d2 JH |
1973 | /* Edges with SPECULATIVE flag represents indirect calls that was |
1974 | speculatively turned into direct (i.e. by profile feedback). | |
1975 | The final code sequence will have form: | |
1976 | ||
1977 | if (call_target == expected_fn) | |
1978 | expected_fn (); | |
1979 | else | |
1980 | call_target (); | |
1981 | ||
1982 | Every speculative call is represented by three components attached | |
1983 | to a same call statement: | |
1984 | 1) a direct call (to expected_fn) | |
1985 | 2) an indirect call (to call_target) | |
dfea3d6f | 1986 | 3) a IPA_REF_ADDR reference to expected_fn. |
042ae7d2 JH |
1987 | |
1988 | Optimizers may later redirect direct call to clone, so 1) and 3) | |
dfea3d6f | 1989 | do not need to necessarily agree with destination. */ |
042ae7d2 | 1990 | unsigned int speculative : 1; |
f9bb202b JH |
1991 | /* Set to true when caller is a constructor or destructor of polymorphic |
1992 | type. */ | |
1993 | unsigned in_polymorphic_cdtor : 1; | |
3dafb85c | 1994 | |
f13fe18b JH |
1995 | /* Return true if call must bind to current definition. */ |
1996 | bool binds_to_current_def_p (); | |
1997 | ||
1bad9c18 JH |
1998 | /* Expected frequency of executions within the function. |
1999 | When set to CGRAPH_FREQ_BASE, the edge is expected to be called once | |
2000 | per function call. The range is 0 to CGRAPH_FREQ_MAX. */ | |
2001 | int frequency (); | |
41f0e819 JH |
2002 | |
2003 | /* Expected frequency of executions within the function. */ | |
2004 | sreal sreal_frequency (); | |
3dafb85c | 2005 | private: |
8b25212d ML |
2006 | /* Unique id of the edge. */ |
2007 | int m_uid; | |
2008 | ||
db30281f ML |
2009 | /* Summary id that is recycled. */ |
2010 | int m_summary_id; | |
2011 | ||
3dafb85c ML |
2012 | /* Remove the edge from the list of the callers of the callee. */ |
2013 | void remove_caller (void); | |
2014 | ||
2015 | /* Remove the edge from the list of the callees of the caller. */ | |
2016 | void remove_callee (void); | |
90988f77 ML |
2017 | |
2018 | /* Set callee N of call graph edge and add it to the corresponding set of | |
2019 | callers. */ | |
2020 | void set_callee (cgraph_node *n); | |
2021 | ||
2022 | /* Output flags of edge to a file F. */ | |
2023 | void dump_edge_flags (FILE *f); | |
2024 | ||
2025 | /* Verify that call graph edge corresponds to DECL from the associated | |
2026 | statement. Return true if the verification should fail. */ | |
2027 | bool verify_corresponds_to_fndecl (tree decl); | |
1c4a429a JH |
2028 | }; |
2029 | ||
45a80bb9 JH |
2030 | #define CGRAPH_FREQ_BASE 1000 |
2031 | #define CGRAPH_FREQ_MAX 100000 | |
2032 | ||
8a4a83ed JH |
2033 | /* The varpool data structure. |
2034 | Each static variable decl has assigned varpool_node. */ | |
e69529cd | 2035 | |
6c1dae73 MS |
2036 | struct GTY((tag ("SYMTAB_VARIABLE"))) varpool_node : public symtab_node |
2037 | { | |
a65d584d ML |
2038 | /* Constructor. */ |
2039 | explicit varpool_node () | |
2040 | : symtab_node (SYMTAB_VARIABLE), output (0), dynamically_initialized (0), | |
2041 | tls_model (TLS_MODEL_NONE), used_by_single_function (0) | |
2042 | {} | |
2043 | ||
9041d2e6 ML |
2044 | /* Dump given varpool node to F. */ |
2045 | void dump (FILE *f); | |
2046 | ||
2047 | /* Dump given varpool node to stderr. */ | |
2048 | void DEBUG_FUNCTION debug (void); | |
2049 | ||
2050 | /* Remove variable from symbol table. */ | |
2051 | void remove (void); | |
2052 | ||
2053 | /* Remove node initializer when it is no longer needed. */ | |
2054 | void remove_initializer (void); | |
2055 | ||
2056 | void analyze (void); | |
2057 | ||
2058 | /* Return variable availability. */ | |
f13fe18b | 2059 | availability get_availability (symtab_node *ref = NULL); |
9041d2e6 ML |
2060 | |
2061 | /* When doing LTO, read variable's constructor from disk if | |
2062 | it is not already present. */ | |
2063 | tree get_constructor (void); | |
2064 | ||
2065 | /* Return true if variable has constructor that can be used for folding. */ | |
2066 | bool ctor_useable_for_folding_p (void); | |
2067 | ||
2068 | /* For given variable pool node, walk the alias chain to return the function | |
2069 | the variable is alias of. Do not walk through thunks. | |
f13fe18b JH |
2070 | When AVAILABILITY is non-NULL, get minimal availability in the chain. |
2071 | When REF is non-NULL, assume that reference happens in symbol REF | |
2072 | when determining the availability. */ | |
9041d2e6 | 2073 | inline varpool_node *ultimate_alias_target |
f13fe18b | 2074 | (availability *availability = NULL, symtab_node *ref = NULL); |
9041d2e6 ML |
2075 | |
2076 | /* Return node that alias is aliasing. */ | |
2077 | inline varpool_node *get_alias_target (void); | |
2078 | ||
2079 | /* Output one variable, if necessary. Return whether we output it. */ | |
2080 | bool assemble_decl (void); | |
2081 | ||
2082 | /* For variables in named sections make sure get_variable_section | |
2083 | is called before we switch to those sections. Then section | |
2084 | conflicts between read-only and read-only requiring relocations | |
2085 | sections can be resolved. */ | |
2086 | void finalize_named_section_flags (void); | |
2087 | ||
dfea3d6f | 2088 | /* Call callback on varpool symbol and aliases associated to varpool symbol. |
9041d2e6 ML |
2089 | When INCLUDE_OVERWRITABLE is false, overwritable aliases and thunks are |
2090 | skipped. */ | |
31de7606 JH |
2091 | bool call_for_symbol_and_aliases (bool (*callback) (varpool_node *, void *), |
2092 | void *data, | |
2093 | bool include_overwritable); | |
9041d2e6 ML |
2094 | |
2095 | /* Return true when variable should be considered externally visible. */ | |
2096 | bool externally_visible_p (void); | |
2097 | ||
2098 | /* Return true when all references to variable must be visible | |
2099 | in ipa_ref_list. | |
2100 | i.e. if the variable is not externally visible or not used in some magic | |
2101 | way (asm statement or such). | |
2102 | The magic uses are all summarized in force_output flag. */ | |
2103 | inline bool all_refs_explicit_p (); | |
2104 | ||
2105 | /* Return true when variable can be removed from variable pool | |
2106 | if all direct calls are eliminated. */ | |
2107 | inline bool can_remove_if_no_refs_p (void); | |
2108 | ||
3dafb85c ML |
2109 | /* Add the variable DECL to the varpool. |
2110 | Unlike finalize_decl function is intended to be used | |
2111 | by middle end and allows insertion of new variable at arbitrary point | |
2112 | of compilation. */ | |
2113 | static void add (tree decl); | |
2114 | ||
9041d2e6 ML |
2115 | /* Return varpool node for given symbol and check it is a function. */ |
2116 | static inline varpool_node *get (const_tree decl); | |
2117 | ||
2118 | /* Mark DECL as finalized. By finalizing the declaration, frontend instruct | |
2119 | the middle end to output the variable to asm file, if needed or externally | |
2120 | visible. */ | |
2121 | static void finalize_decl (tree decl); | |
2122 | ||
9041d2e6 ML |
2123 | /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful. |
2124 | Extra name aliases are output whenever DECL is output. */ | |
2125 | static varpool_node * create_extra_name_alias (tree alias, tree decl); | |
2126 | ||
2127 | /* Attempt to mark ALIAS as an alias to DECL. Return TRUE if successful. | |
2128 | Extra name aliases are output whenever DECL is output. */ | |
2129 | static varpool_node * create_alias (tree, tree); | |
2130 | ||
2131 | /* Dump the variable pool to F. */ | |
2132 | static void dump_varpool (FILE *f); | |
2133 | ||
2134 | /* Dump the variable pool to stderr. */ | |
2135 | static void DEBUG_FUNCTION debug_varpool (void); | |
2136 | ||
2137 | /* Allocate new callgraph node and insert it into basic data structures. */ | |
2138 | static varpool_node *create_empty (void); | |
2139 | ||
2140 | /* Return varpool node assigned to DECL. Create new one when needed. */ | |
2141 | static varpool_node *get_create (tree decl); | |
2142 | ||
2143 | /* Given an assembler name, lookup node. */ | |
2144 | static varpool_node *get_for_asmname (tree asmname); | |
2145 | ||
6b02a499 | 2146 | /* Set when variable is scheduled to be assembled. */ |
b4e19405 | 2147 | unsigned output : 1; |
eb1d8159 | 2148 | |
59b36ecf JJ |
2149 | /* Set if the variable is dynamically initialized, except for |
2150 | function local statics. */ | |
2151 | unsigned dynamically_initialized : 1; | |
56363ffd JH |
2152 | |
2153 | ENUM_BITFIELD(tls_model) tls_model : 3; | |
eb6a09a7 JH |
2154 | |
2155 | /* Set if the variable is known to be used by single function only. | |
dfea3d6f | 2156 | This is computed by ipa_single_use pass and used by late optimizations |
eb6a09a7 JH |
2157 | in places where optimization would be valid for local static variable |
2158 | if we did not do any inter-procedural code movement. */ | |
2159 | unsigned used_by_single_function : 1; | |
d52f5295 | 2160 | |
9041d2e6 ML |
2161 | private: |
2162 | /* Assemble thunks and aliases associated to varpool node. */ | |
2163 | void assemble_aliases (void); | |
31de7606 JH |
2164 | |
2165 | /* Worker for call_for_node_and_aliases. */ | |
2166 | bool call_for_symbol_and_aliases_1 (bool (*callback) (varpool_node *, void *), | |
2167 | void *data, | |
2168 | bool include_overwritable); | |
e69529cd JH |
2169 | }; |
2170 | ||
65d630d4 | 2171 | /* Every top level asm statement is put into a asm_node. */ |
474eccc6 | 2172 | |
65d630d4 | 2173 | struct GTY(()) asm_node { |
3dafb85c ML |
2174 | |
2175 | ||
474eccc6 | 2176 | /* Next asm node. */ |
3dafb85c | 2177 | asm_node *next; |
474eccc6 ILT |
2178 | /* String for this asm node. */ |
2179 | tree asm_str; | |
2180 | /* Ordering of all cgraph nodes. */ | |
2181 | int order; | |
2182 | }; | |
2183 | ||
5d59b5e1 LC |
2184 | /* Report whether or not THIS symtab node is a function, aka cgraph_node. */ |
2185 | ||
2186 | template <> | |
2187 | template <> | |
2188 | inline bool | |
7de90a6c | 2189 | is_a_helper <cgraph_node *>::test (symtab_node *p) |
5d59b5e1 | 2190 | { |
d52f5295 | 2191 | return p && p->type == SYMTAB_FUNCTION; |
5d59b5e1 LC |
2192 | } |
2193 | ||
dfea3d6f | 2194 | /* Report whether or not THIS symtab node is a variable, aka varpool_node. */ |
5d59b5e1 LC |
2195 | |
2196 | template <> | |
2197 | template <> | |
2198 | inline bool | |
7de90a6c | 2199 | is_a_helper <varpool_node *>::test (symtab_node *p) |
5d59b5e1 | 2200 | { |
d52f5295 | 2201 | return p && p->type == SYMTAB_VARIABLE; |
5d59b5e1 LC |
2202 | } |
2203 | ||
3dafb85c ML |
2204 | typedef void (*cgraph_edge_hook)(cgraph_edge *, void *); |
2205 | typedef void (*cgraph_node_hook)(cgraph_node *, void *); | |
2206 | typedef void (*varpool_node_hook)(varpool_node *, void *); | |
2207 | typedef void (*cgraph_2edge_hook)(cgraph_edge *, cgraph_edge *, void *); | |
2208 | typedef void (*cgraph_2node_hook)(cgraph_node *, cgraph_node *, void *); | |
2209 | ||
2210 | struct cgraph_edge_hook_list; | |
2211 | struct cgraph_node_hook_list; | |
2212 | struct varpool_node_hook_list; | |
2213 | struct cgraph_2edge_hook_list; | |
2214 | struct cgraph_2node_hook_list; | |
2215 | ||
2216 | /* Map from a symbol to initialization/finalization priorities. */ | |
2217 | struct GTY(()) symbol_priority_map { | |
3dafb85c ML |
2218 | priority_type init; |
2219 | priority_type fini; | |
2220 | }; | |
2221 | ||
2222 | enum symtab_state | |
f45e0ad1 | 2223 | { |
66058468 | 2224 | /* Frontend is parsing and finalizing functions. */ |
3dafb85c | 2225 | PARSING, |
f45e0ad1 | 2226 | /* Callgraph is being constructed. It is safe to add new functions. */ |
3dafb85c | 2227 | CONSTRUCTION, |
17e0fc92 | 2228 | /* Callgraph is being streamed-in at LTO time. */ |
3dafb85c | 2229 | LTO_STREAMING, |
17e0fc92 | 2230 | /* Callgraph is built and early IPA passes are being run. */ |
3dafb85c | 2231 | IPA, |
7a388ee4 | 2232 | /* Callgraph is built and all functions are transformed to SSA form. */ |
3dafb85c | 2233 | IPA_SSA, |
17e0fc92 JH |
2234 | /* All inline decisions are done; it is now possible to remove extern inline |
2235 | functions and virtual call targets. */ | |
2236 | IPA_SSA_AFTER_INLINING, | |
f45e0ad1 | 2237 | /* Functions are now ordered and being passed to RTL expanders. */ |
3dafb85c | 2238 | EXPANSION, |
f45e0ad1 | 2239 | /* All cgraph expansion is done. */ |
3dafb85c | 2240 | FINISHED |
f45e0ad1 | 2241 | }; |
1c4a429a | 2242 | |
7edd9b15 | 2243 | struct asmname_hasher : ggc_ptr_hash <symtab_node> |
2a22f99c | 2244 | { |
2a22f99c | 2245 | typedef const_tree compare_type; |
2a22f99c TS |
2246 | |
2247 | static hashval_t hash (symtab_node *n); | |
2248 | static bool equal (symtab_node *n, const_tree t); | |
2a22f99c TS |
2249 | }; |
2250 | ||
3dafb85c ML |
2251 | class GTY((tag ("SYMTAB"))) symbol_table |
2252 | { | |
2253 | public: | |
99b1c316 MS |
2254 | friend struct symtab_node; |
2255 | friend struct cgraph_node; | |
2256 | friend struct cgraph_edge; | |
3dafb85c | 2257 | |
019f36a6 JH |
2258 | symbol_table (): |
2259 | cgraph_count (0), cgraph_max_uid (1), cgraph_max_summary_id (0), | |
2260 | edges_count (0), edges_max_uid (1), edges_max_summary_id (0), | |
2261 | cgraph_released_summary_ids (), edge_released_summary_ids (), | |
2262 | nodes (NULL), asmnodes (NULL), asm_last_node (NULL), | |
b74d8dc4 | 2263 | order (0), max_unit (0), global_info_ready (false), state (PARSING), |
019f36a6 JH |
2264 | function_flags_ready (false), cpp_implicit_aliases_done (false), |
2265 | section_hash (NULL), assembler_name_hash (NULL), init_priority_hash (NULL), | |
2266 | dump_file (NULL), ipa_clones_dump_file (NULL), cloned_nodes (), | |
2267 | m_first_edge_removal_hook (NULL), m_first_cgraph_removal_hook (NULL), | |
2268 | m_first_edge_duplicated_hook (NULL), m_first_cgraph_duplicated_hook (NULL), | |
2269 | m_first_cgraph_insertion_hook (NULL), m_first_varpool_insertion_hook (NULL), | |
2270 | m_first_varpool_removal_hook (NULL) | |
4008290f ML |
2271 | { |
2272 | } | |
2273 | ||
3dafb85c | 2274 | /* Initialize callgraph dump file. */ |
c582198b | 2275 | void initialize (void); |
3dafb85c ML |
2276 | |
2277 | /* Register a top-level asm statement ASM_STR. */ | |
2278 | inline asm_node *finalize_toplevel_asm (tree asm_str); | |
2279 | ||
2280 | /* Analyze the whole compilation unit once it is parsed completely. */ | |
2281 | void finalize_compilation_unit (void); | |
2282 | ||
2283 | /* C++ frontend produce same body aliases all over the place, even before PCH | |
2284 | gets streamed out. It relies on us linking the aliases with their function | |
dfea3d6f JJ |
2285 | in order to do the fixups, but ipa-ref is not PCH safe. Consequently we |
2286 | first produce aliases without links, but once C++ FE is sure it won't | |
2287 | stream PCH we build the links via this function. */ | |
3dafb85c ML |
2288 | void process_same_body_aliases (void); |
2289 | ||
2290 | /* Perform simple optimizations based on callgraph. */ | |
2291 | void compile (void); | |
2292 | ||
2293 | /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these | |
2294 | functions into callgraph in a way so they look like ordinary reachable | |
2295 | functions inserted into callgraph already at construction time. */ | |
2296 | void process_new_functions (void); | |
2297 | ||
2298 | /* Once all functions from compilation unit are in memory, produce all clones | |
2299 | and update all calls. We might also do this on demand if we don't want to | |
2300 | bring all functions to memory prior compilation, but current WHOPR | |
026c3cfd | 2301 | implementation does that and it is bit easier to keep everything right |
3dafb85c ML |
2302 | in this order. */ |
2303 | void materialize_all_clones (void); | |
2304 | ||
2305 | /* Register a symbol NODE. */ | |
2306 | inline void register_symbol (symtab_node *node); | |
2307 | ||
2308 | inline void | |
2309 | clear_asm_symbols (void) | |
2310 | { | |
2311 | asmnodes = NULL; | |
2312 | asm_last_node = NULL; | |
2313 | } | |
2314 | ||
2315 | /* Perform reachability analysis and reclaim all unreachable nodes. */ | |
17e0fc92 | 2316 | bool remove_unreachable_nodes (FILE *file); |
3dafb85c ML |
2317 | |
2318 | /* Optimization of function bodies might've rendered some variables as | |
2319 | unnecessary so we want to avoid these from being compiled. Re-do | |
2320 | reachability starting from variables that are either externally visible | |
2321 | or was referred from the asm output routines. */ | |
2322 | void remove_unreferenced_decls (void); | |
2323 | ||
2324 | /* Unregister a symbol NODE. */ | |
2325 | inline void unregister (symtab_node *node); | |
2326 | ||
2327 | /* Allocate new callgraph node and insert it into basic data structures. */ | |
2328 | cgraph_node *create_empty (void); | |
2329 | ||
74644756 ML |
2330 | /* Release a callgraph NODE. */ |
2331 | void release_symbol (cgraph_node *node); | |
3dafb85c ML |
2332 | |
2333 | /* Output all variables enqueued to be assembled. */ | |
2334 | bool output_variables (void); | |
2335 | ||
3dafb85c ML |
2336 | /* Weakrefs may be associated to external decls and thus not output |
2337 | at expansion time. Emit all necessary aliases. */ | |
2338 | void output_weakrefs (void); | |
2339 | ||
2340 | /* Return first static symbol with definition. */ | |
2341 | inline symtab_node *first_symbol (void); | |
2342 | ||
2343 | /* Return first assembler symbol. */ | |
2344 | inline asm_node * | |
2345 | first_asm_symbol (void) | |
2346 | { | |
2347 | return asmnodes; | |
2348 | } | |
2349 | ||
2350 | /* Return first static symbol with definition. */ | |
2351 | inline symtab_node *first_defined_symbol (void); | |
2352 | ||
2353 | /* Return first variable. */ | |
2354 | inline varpool_node *first_variable (void); | |
2355 | ||
2356 | /* Return next variable after NODE. */ | |
2357 | inline varpool_node *next_variable (varpool_node *node); | |
2358 | ||
2359 | /* Return first static variable with initializer. */ | |
2360 | inline varpool_node *first_static_initializer (void); | |
2361 | ||
2362 | /* Return next static variable with initializer after NODE. */ | |
2363 | inline varpool_node *next_static_initializer (varpool_node *node); | |
2364 | ||
2365 | /* Return first static variable with definition. */ | |
2366 | inline varpool_node *first_defined_variable (void); | |
2367 | ||
2368 | /* Return next static variable with definition after NODE. */ | |
2369 | inline varpool_node *next_defined_variable (varpool_node *node); | |
2370 | ||
2371 | /* Return first function with body defined. */ | |
2372 | inline cgraph_node *first_defined_function (void); | |
2373 | ||
2374 | /* Return next function with body defined after NODE. */ | |
2375 | inline cgraph_node *next_defined_function (cgraph_node *node); | |
2376 | ||
2377 | /* Return first function. */ | |
2378 | inline cgraph_node *first_function (void); | |
2379 | ||
2380 | /* Return next function. */ | |
2381 | inline cgraph_node *next_function (cgraph_node *node); | |
2382 | ||
2383 | /* Return first function with body defined. */ | |
2384 | cgraph_node *first_function_with_gimple_body (void); | |
2385 | ||
2386 | /* Return next reachable static variable with initializer after NODE. */ | |
2387 | inline cgraph_node *next_function_with_gimple_body (cgraph_node *node); | |
2388 | ||
2389 | /* Register HOOK to be called with DATA on each removed edge. */ | |
2390 | cgraph_edge_hook_list *add_edge_removal_hook (cgraph_edge_hook hook, | |
2391 | void *data); | |
2392 | ||
2393 | /* Remove ENTRY from the list of hooks called on removing edges. */ | |
2394 | void remove_edge_removal_hook (cgraph_edge_hook_list *entry); | |
2395 | ||
2396 | /* Register HOOK to be called with DATA on each removed node. */ | |
2397 | cgraph_node_hook_list *add_cgraph_removal_hook (cgraph_node_hook hook, | |
2398 | void *data); | |
2399 | ||
2400 | /* Remove ENTRY from the list of hooks called on removing nodes. */ | |
2401 | void remove_cgraph_removal_hook (cgraph_node_hook_list *entry); | |
2402 | ||
2403 | /* Register HOOK to be called with DATA on each removed node. */ | |
2404 | varpool_node_hook_list *add_varpool_removal_hook (varpool_node_hook hook, | |
2405 | void *data); | |
2406 | ||
2407 | /* Remove ENTRY from the list of hooks called on removing nodes. */ | |
2408 | void remove_varpool_removal_hook (varpool_node_hook_list *entry); | |
2409 | ||
2410 | /* Register HOOK to be called with DATA on each inserted node. */ | |
2411 | cgraph_node_hook_list *add_cgraph_insertion_hook (cgraph_node_hook hook, | |
2412 | void *data); | |
2413 | ||
2414 | /* Remove ENTRY from the list of hooks called on inserted nodes. */ | |
2415 | void remove_cgraph_insertion_hook (cgraph_node_hook_list *entry); | |
2416 | ||
2417 | /* Register HOOK to be called with DATA on each inserted node. */ | |
2418 | varpool_node_hook_list *add_varpool_insertion_hook (varpool_node_hook hook, | |
2419 | void *data); | |
2420 | ||
2421 | /* Remove ENTRY from the list of hooks called on inserted nodes. */ | |
2422 | void remove_varpool_insertion_hook (varpool_node_hook_list *entry); | |
2423 | ||
2424 | /* Register HOOK to be called with DATA on each duplicated edge. */ | |
2425 | cgraph_2edge_hook_list *add_edge_duplication_hook (cgraph_2edge_hook hook, | |
2426 | void *data); | |
2427 | /* Remove ENTRY from the list of hooks called on duplicating edges. */ | |
2428 | void remove_edge_duplication_hook (cgraph_2edge_hook_list *entry); | |
2429 | ||
2430 | /* Register HOOK to be called with DATA on each duplicated node. */ | |
2431 | cgraph_2node_hook_list *add_cgraph_duplication_hook (cgraph_2node_hook hook, | |
2432 | void *data); | |
2433 | ||
2434 | /* Remove ENTRY from the list of hooks called on duplicating nodes. */ | |
2435 | void remove_cgraph_duplication_hook (cgraph_2node_hook_list *entry); | |
2436 | ||
2437 | /* Call all edge removal hooks. */ | |
2438 | void call_edge_removal_hooks (cgraph_edge *e); | |
2439 | ||
2440 | /* Call all node insertion hooks. */ | |
2441 | void call_cgraph_insertion_hooks (cgraph_node *node); | |
2442 | ||
2443 | /* Call all node removal hooks. */ | |
2444 | void call_cgraph_removal_hooks (cgraph_node *node); | |
2445 | ||
2446 | /* Call all node duplication hooks. */ | |
2447 | void call_cgraph_duplication_hooks (cgraph_node *node, cgraph_node *node2); | |
2448 | ||
2449 | /* Call all edge duplication hooks. */ | |
2450 | void call_edge_duplication_hooks (cgraph_edge *cs1, cgraph_edge *cs2); | |
2451 | ||
2452 | /* Call all node removal hooks. */ | |
2453 | void call_varpool_removal_hooks (varpool_node *node); | |
2454 | ||
2455 | /* Call all node insertion hooks. */ | |
2456 | void call_varpool_insertion_hooks (varpool_node *node); | |
2457 | ||
2458 | /* Arrange node to be first in its entry of assembler_name_hash. */ | |
2459 | void symtab_prevail_in_asm_name_hash (symtab_node *node); | |
2460 | ||
dfea3d6f | 2461 | /* Initialize asm name hash unless. */ |
3dafb85c ML |
2462 | void symtab_initialize_asm_name_hash (void); |
2463 | ||
2464 | /* Set the DECL_ASSEMBLER_NAME and update symtab hashtables. */ | |
2465 | void change_decl_assembler_name (tree decl, tree name); | |
e69529cd | 2466 | |
6c52831d ML |
2467 | /* Dump symbol table to F. */ |
2468 | void dump (FILE *f); | |
2469 | ||
34e64622 GB |
2470 | /* Dump symbol table to F in graphviz format. */ |
2471 | void dump_graphviz (FILE *f); | |
2472 | ||
6c52831d | 2473 | /* Dump symbol table to stderr. */ |
e94497fb | 2474 | void DEBUG_FUNCTION debug (void); |
6c52831d | 2475 | |
db30281f ML |
2476 | /* Assign a new summary ID for the callgraph NODE. */ |
2477 | inline int assign_summary_id (cgraph_node *node) | |
2478 | { | |
fe248a88 ML |
2479 | if (!cgraph_released_summary_ids.is_empty ()) |
2480 | node->m_summary_id = cgraph_released_summary_ids.pop (); | |
2481 | else | |
2482 | node->m_summary_id = cgraph_max_summary_id++; | |
2483 | ||
db30281f ML |
2484 | return node->m_summary_id; |
2485 | } | |
2486 | ||
2487 | /* Assign a new summary ID for the callgraph EDGE. */ | |
2488 | inline int assign_summary_id (cgraph_edge *edge) | |
2489 | { | |
fe248a88 ML |
2490 | if (!edge_released_summary_ids.is_empty ()) |
2491 | edge->m_summary_id = edge_released_summary_ids.pop (); | |
2492 | else | |
2493 | edge->m_summary_id = edges_max_summary_id++; | |
2494 | ||
db30281f ML |
2495 | return edge->m_summary_id; |
2496 | } | |
2497 | ||
71e54687 JH |
2498 | /* Return true if assembler names NAME1 and NAME2 leads to the same symbol |
2499 | name. */ | |
2500 | static bool assembler_names_equal_p (const char *name1, const char *name2); | |
2501 | ||
3dafb85c ML |
2502 | int cgraph_count; |
2503 | int cgraph_max_uid; | |
db30281f | 2504 | int cgraph_max_summary_id; |
3dafb85c ML |
2505 | |
2506 | int edges_count; | |
2507 | int edges_max_uid; | |
db30281f | 2508 | int edges_max_summary_id; |
3dafb85c | 2509 | |
fe248a88 ML |
2510 | /* Vector of released summary IDS for cgraph nodes. */ |
2511 | vec<int> GTY ((skip)) cgraph_released_summary_ids; | |
2512 | ||
2513 | /* Vector of released summary IDS for cgraph nodes. */ | |
2514 | vec<int> GTY ((skip)) edge_released_summary_ids; | |
2515 | ||
019f36a6 JH |
2516 | /* Return symbol used to separate symbol name from suffix. */ |
2517 | static char symbol_suffix_separator (); | |
2518 | ||
3dafb85c ML |
2519 | symtab_node* GTY(()) nodes; |
2520 | asm_node* GTY(()) asmnodes; | |
2521 | asm_node* GTY(()) asm_last_node; | |
3dafb85c ML |
2522 | |
2523 | /* The order index of the next symtab node to be created. This is | |
2524 | used so that we can sort the cgraph nodes in order by when we saw | |
2525 | them, to support -fno-toplevel-reorder. */ | |
2526 | int order; | |
2527 | ||
b74d8dc4 JH |
2528 | /* Maximal unit ID used. */ |
2529 | int max_unit; | |
2530 | ||
3dafb85c ML |
2531 | /* Set when whole unit has been analyzed so we can access global info. */ |
2532 | bool global_info_ready; | |
2533 | /* What state callgraph is in right now. */ | |
2534 | enum symtab_state state; | |
2535 | /* Set when the cgraph is fully build and the basic flags are computed. */ | |
2536 | bool function_flags_ready; | |
2537 | ||
2538 | bool cpp_implicit_aliases_done; | |
2539 | ||
dfea3d6f | 2540 | /* Hash table used to hold sections. */ |
2a22f99c | 2541 | hash_table<section_name_hasher> *GTY(()) section_hash; |
3dafb85c ML |
2542 | |
2543 | /* Hash table used to convert assembler names into nodes. */ | |
2a22f99c | 2544 | hash_table<asmname_hasher> *assembler_name_hash; |
3dafb85c ML |
2545 | |
2546 | /* Hash table used to hold init priorities. */ | |
b086d530 | 2547 | hash_map<symtab_node *, symbol_priority_map> *init_priority_hash; |
3dafb85c ML |
2548 | |
2549 | FILE* GTY ((skip)) dump_file; | |
2550 | ||
0bdad123 ML |
2551 | FILE* GTY ((skip)) ipa_clones_dump_file; |
2552 | ||
2553 | hash_set <const cgraph_node *> GTY ((skip)) cloned_nodes; | |
2554 | ||
3dafb85c | 2555 | private: |
3dafb85c | 2556 | /* Allocate a cgraph_edge structure and fill it with data according to the |
3187c8a5 MJ |
2557 | parameters of which only CALLEE can be NULL (when creating an indirect |
2558 | call edge). CLONING_P should be set if properties that are copied from an | |
2559 | original edge should not be calculated. */ | |
3dafb85c | 2560 | cgraph_edge *create_edge (cgraph_node *caller, cgraph_node *callee, |
1bad9c18 | 2561 | gcall *call_stmt, profile_count count, |
3187c8a5 | 2562 | bool indir_unknown_callee, bool cloning_p); |
3dafb85c ML |
2563 | |
2564 | /* Put the edge onto the free list. */ | |
2565 | void free_edge (cgraph_edge *e); | |
2566 | ||
2567 | /* Insert NODE to assembler name hash. */ | |
2568 | void insert_to_assembler_name_hash (symtab_node *node, bool with_clones); | |
2569 | ||
2570 | /* Remove NODE from assembler name hash. */ | |
2571 | void unlink_from_assembler_name_hash (symtab_node *node, bool with_clones); | |
2572 | ||
2573 | /* Hash asmnames ignoring the user specified marks. */ | |
2574 | static hashval_t decl_assembler_name_hash (const_tree asmname); | |
2575 | ||
2576 | /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */ | |
2577 | static bool decl_assembler_name_equal (tree decl, const_tree asmname); | |
2578 | ||
2a22f99c | 2579 | friend struct asmname_hasher; |
3dafb85c ML |
2580 | |
2581 | /* List of hooks triggered when an edge is removed. */ | |
2582 | cgraph_edge_hook_list * GTY((skip)) m_first_edge_removal_hook; | |
dfea3d6f | 2583 | /* List of hooks trigger_red when a cgraph node is removed. */ |
3dafb85c ML |
2584 | cgraph_node_hook_list * GTY((skip)) m_first_cgraph_removal_hook; |
2585 | /* List of hooks triggered when an edge is duplicated. */ | |
2586 | cgraph_2edge_hook_list * GTY((skip)) m_first_edge_duplicated_hook; | |
2587 | /* List of hooks triggered when a node is duplicated. */ | |
2588 | cgraph_2node_hook_list * GTY((skip)) m_first_cgraph_duplicated_hook; | |
2589 | /* List of hooks triggered when an function is inserted. */ | |
2590 | cgraph_node_hook_list * GTY((skip)) m_first_cgraph_insertion_hook; | |
2591 | /* List of hooks triggered when an variable is inserted. */ | |
2592 | varpool_node_hook_list * GTY((skip)) m_first_varpool_insertion_hook; | |
2593 | /* List of hooks triggered when a node is removed. */ | |
2594 | varpool_node_hook_list * GTY((skip)) m_first_varpool_removal_hook; | |
2595 | }; | |
2596 | ||
2597 | extern GTY(()) symbol_table *symtab; | |
2598 | ||
2599 | extern vec<cgraph_node *> cgraph_new_nodes; | |
2aae7680 | 2600 | |
2a22f99c TS |
2601 | inline hashval_t |
2602 | asmname_hasher::hash (symtab_node *n) | |
2603 | { | |
2604 | return symbol_table::decl_assembler_name_hash | |
2605 | (DECL_ASSEMBLER_NAME (n->decl)); | |
2606 | } | |
2607 | ||
2608 | inline bool | |
2609 | asmname_hasher::equal (symtab_node *n, const_tree t) | |
2610 | { | |
2611 | return symbol_table::decl_assembler_name_equal (n->decl, t); | |
2612 | } | |
2613 | ||
1c4a429a | 2614 | /* In cgraph.c */ |
3edf64aa | 2615 | void cgraph_c_finalize (void); |
12123452 | 2616 | void release_function_body (tree); |
3dafb85c | 2617 | cgraph_indirect_call_info *cgraph_allocate_init_indirect_info (void); |
d52f5295 | 2618 | |
355fe088 | 2619 | void cgraph_update_edges_for_call_stmt (gimple *, tree, gimple *); |
1bb17c21 JH |
2620 | bool cgraph_function_possibly_inlined_p (tree); |
2621 | ||
61a05df1 | 2622 | const char* cgraph_inline_failed_string (cgraph_inline_failed_t); |
1cf11770 | 2623 | cgraph_inline_failed_type_t cgraph_inline_failed_type (cgraph_inline_failed_t); |
6b02a499 | 2624 | |
9c8305f8 | 2625 | /* In cgraphunit.c */ |
3edf64aa | 2626 | void cgraphunit_c_finalize (void); |
6d8fd122 | 2627 | int tp_first_run_node_cmp (const void *pa, const void *pb); |
3edf64aa | 2628 | |
3649b9b7 ST |
2629 | /* Initialize datastructures so DECL is a function in lowered gimple form. |
2630 | IN_SSA is true if the gimple is in SSA. */ | |
3995f3a2 | 2631 | basic_block init_lowered_empty_function (tree, bool, profile_count); |
66a20fc2 | 2632 | |
44662f68 EB |
2633 | tree thunk_adjust (gimple_stmt_iterator *, tree, bool, HOST_WIDE_INT, tree, |
2634 | HOST_WIDE_INT); | |
66a20fc2 JH |
2635 | /* In cgraphclones.c */ |
2636 | ||
7958186b MP |
2637 | tree clone_function_name_numbered (const char *name, const char *suffix); |
2638 | tree clone_function_name_numbered (tree decl, const char *suffix); | |
2639 | tree clone_function_name (const char *name, const char *suffix, | |
2640 | unsigned long number); | |
53aedcce MP |
2641 | tree clone_function_name (tree decl, const char *suffix, |
2642 | unsigned long number); | |
7958186b | 2643 | tree clone_function_name (tree decl, const char *suffix); |
d52f5295 | 2644 | |
d52f5295 | 2645 | void tree_function_versioning (tree, tree, vec<ipa_replace_map *, va_gc> *, |
ff6686d2 MJ |
2646 | ipa_param_adjustments *, |
2647 | bool, bitmap, basic_block); | |
9c8305f8 | 2648 | |
0bdad123 ML |
2649 | void dump_callgraph_transformation (const cgraph_node *original, |
2650 | const cgraph_node *clone, | |
2651 | const char *suffix); | |
917948d3 | 2652 | /* In cgraphbuild.c */ |
9187e02d | 2653 | int compute_call_stmt_bb_frequency (tree, basic_block bb); |
9c8305f8 | 2654 | void record_references_in_initializer (tree, bool); |
917948d3 | 2655 | |
ca31b95f | 2656 | /* In ipa.c */ |
9c8305f8 | 2657 | void cgraph_build_static_cdtor (char which, tree body, int priority); |
2e14744f | 2658 | bool ipa_discover_variable_flags (void); |
ca31b95f | 2659 | |
8a4a83ed | 2660 | /* In varpool.c */ |
6a6dac52 | 2661 | tree ctor_for_folding (tree); |
68e56cc4 | 2662 | |
27d020cf JH |
2663 | /* In ipa-inline-analysis.c */ |
2664 | void initialize_inline_failed (struct cgraph_edge *); | |
2665 | bool speculation_useful_p (struct cgraph_edge *e, bool anticipate_inlining); | |
2666 | ||
d52f5295 ML |
2667 | /* Return true when the symbol is real symbol, i.e. it is not inline clone |
2668 | or abstract function kept for debug info purposes only. */ | |
2669 | inline bool | |
2670 | symtab_node::real_symbol_p (void) | |
2671 | { | |
2672 | cgraph_node *cnode; | |
2673 | ||
00de328a | 2674 | if (DECL_ABSTRACT_P (decl)) |
d52f5295 | 2675 | return false; |
71e54687 JH |
2676 | if (transparent_alias && definition) |
2677 | return false; | |
d52f5295 ML |
2678 | if (!is_a <cgraph_node *> (this)) |
2679 | return true; | |
2680 | cnode = dyn_cast <cgraph_node *> (this); | |
a62bfab5 | 2681 | if (cnode->inlined_to) |
d52f5295 ML |
2682 | return false; |
2683 | return true; | |
2684 | } | |
2685 | ||
89330618 | 2686 | /* Return true if DECL should have entry in symbol table if used. |
dfea3d6f | 2687 | Those are functions and static & external variables. */ |
89330618 | 2688 | |
0241e486 | 2689 | static inline bool |
89330618 JH |
2690 | decl_in_symtab_p (const_tree decl) |
2691 | { | |
2692 | return (TREE_CODE (decl) == FUNCTION_DECL | |
2693 | || (TREE_CODE (decl) == VAR_DECL | |
2694 | && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))); | |
2695 | } | |
2696 | ||
d52f5295 ML |
2697 | inline bool |
2698 | symtab_node::in_same_comdat_group_p (symtab_node *target) | |
aede2c10 | 2699 | { |
d52f5295 | 2700 | symtab_node *source = this; |
aede2c10 | 2701 | |
d52f5295 ML |
2702 | if (cgraph_node *cn = dyn_cast <cgraph_node *> (target)) |
2703 | { | |
a62bfab5 ML |
2704 | if (cn->inlined_to) |
2705 | source = cn->inlined_to; | |
d52f5295 ML |
2706 | } |
2707 | if (cgraph_node *cn = dyn_cast <cgraph_node *> (target)) | |
2708 | { | |
a62bfab5 ML |
2709 | if (cn->inlined_to) |
2710 | target = cn->inlined_to; | |
d52f5295 ML |
2711 | } |
2712 | ||
2713 | return source->get_comdat_group () == target->get_comdat_group (); | |
1f00098b JH |
2714 | } |
2715 | ||
d52f5295 ML |
2716 | /* Return node that alias is aliasing. */ |
2717 | ||
2718 | inline symtab_node * | |
2719 | symtab_node::get_alias_target (void) | |
1f00098b | 2720 | { |
3dafb85c | 2721 | ipa_ref *ref = NULL; |
d52f5295 ML |
2722 | iterate_reference (0, ref); |
2723 | gcc_checking_assert (ref->use == IPA_REF_ALIAS); | |
2724 | return ref->referred; | |
1f00098b JH |
2725 | } |
2726 | ||
d52f5295 | 2727 | /* Return next reachable static symbol with initializer after the node. */ |
31de7606 | 2728 | |
d52f5295 ML |
2729 | inline symtab_node * |
2730 | symtab_node::next_defined_symbol (void) | |
1ab24192 | 2731 | { |
d52f5295 ML |
2732 | symtab_node *node1 = next; |
2733 | ||
2734 | for (; node1; node1 = node1->next) | |
2735 | if (node1->definition) | |
2736 | return node1; | |
2737 | ||
2738 | return NULL; | |
1ab24192 JH |
2739 | } |
2740 | ||
31de7606 JH |
2741 | /* Iterates I-th reference in the list, REF is also set. */ |
2742 | ||
2743 | inline ipa_ref * | |
2744 | symtab_node::iterate_reference (unsigned i, ipa_ref *&ref) | |
2745 | { | |
2746 | vec_safe_iterate (ref_list.references, i, &ref); | |
2747 | ||
2748 | return ref; | |
2749 | } | |
2750 | ||
2751 | /* Iterates I-th referring item in the list, REF is also set. */ | |
2752 | ||
2753 | inline ipa_ref * | |
2754 | symtab_node::iterate_referring (unsigned i, ipa_ref *&ref) | |
2755 | { | |
2756 | ref_list.referring.iterate (i, &ref); | |
2757 | ||
2758 | return ref; | |
2759 | } | |
2760 | ||
2761 | /* Iterates I-th referring alias item in the list, REF is also set. */ | |
2762 | ||
2763 | inline ipa_ref * | |
2764 | symtab_node::iterate_direct_aliases (unsigned i, ipa_ref *&ref) | |
2765 | { | |
2766 | ref_list.referring.iterate (i, &ref); | |
2767 | ||
2768 | if (ref && ref->use != IPA_REF_ALIAS) | |
2769 | return NULL; | |
2770 | ||
2771 | return ref; | |
2772 | } | |
2773 | ||
2774 | /* Return true if list contains an alias. */ | |
2775 | ||
2776 | inline bool | |
2777 | symtab_node::has_aliases_p (void) | |
2778 | { | |
2779 | ipa_ref *ref = NULL; | |
31de7606 | 2780 | |
190bbd0b | 2781 | return (iterate_direct_aliases (0, ref) != NULL); |
31de7606 JH |
2782 | } |
2783 | ||
2784 | /* Return true when RESOLUTION indicate that linker will use | |
2785 | the symbol from non-LTO object files. */ | |
2786 | ||
2787 | inline bool | |
2788 | resolution_used_from_other_file_p (enum ld_plugin_symbol_resolution resolution) | |
2789 | { | |
2790 | return (resolution == LDPR_PREVAILING_DEF | |
2791 | || resolution == LDPR_PREEMPTED_REG | |
2792 | || resolution == LDPR_RESOLVED_EXEC | |
2793 | || resolution == LDPR_RESOLVED_DYN); | |
2794 | } | |
2795 | ||
2796 | /* Return true when symtab_node is known to be used from other (non-LTO) | |
2797 | object file. Known only when doing LTO via linker plugin. */ | |
2798 | ||
2799 | inline bool | |
2800 | symtab_node::used_from_object_file_p (void) | |
2801 | { | |
2802 | if (!TREE_PUBLIC (decl) || DECL_EXTERNAL (decl)) | |
2803 | return false; | |
2804 | if (resolution_used_from_other_file_p (resolution)) | |
2805 | return true; | |
2806 | return false; | |
2807 | } | |
2808 | ||
1ab24192 | 2809 | /* Return varpool node for given symbol and check it is a function. */ |
3dafb85c | 2810 | |
9041d2e6 ML |
2811 | inline varpool_node * |
2812 | varpool_node::get (const_tree decl) | |
1ab24192 JH |
2813 | { |
2814 | gcc_checking_assert (TREE_CODE (decl) == VAR_DECL); | |
d52f5295 | 2815 | return dyn_cast<varpool_node *> (symtab_node::get (decl)); |
1ab24192 JH |
2816 | } |
2817 | ||
3dafb85c ML |
2818 | /* Register a symbol NODE. */ |
2819 | ||
2820 | inline void | |
2821 | symbol_table::register_symbol (symtab_node *node) | |
2822 | { | |
2823 | node->next = nodes; | |
2824 | node->previous = NULL; | |
2825 | ||
2826 | if (nodes) | |
2827 | nodes->previous = node; | |
2828 | nodes = node; | |
2829 | ||
2830 | node->order = order++; | |
2831 | } | |
2832 | ||
2833 | /* Register a top-level asm statement ASM_STR. */ | |
2834 | ||
2835 | asm_node * | |
2836 | symbol_table::finalize_toplevel_asm (tree asm_str) | |
2837 | { | |
2838 | asm_node *node; | |
2839 | ||
2840 | node = ggc_cleared_alloc<asm_node> (); | |
2841 | node->asm_str = asm_str; | |
2842 | node->order = order++; | |
2843 | node->next = NULL; | |
2844 | ||
2845 | if (asmnodes == NULL) | |
2846 | asmnodes = node; | |
2847 | else | |
2848 | asm_last_node->next = node; | |
2849 | ||
2850 | asm_last_node = node; | |
2851 | return node; | |
2852 | } | |
2853 | ||
2854 | /* Unregister a symbol NODE. */ | |
2855 | inline void | |
2856 | symbol_table::unregister (symtab_node *node) | |
2857 | { | |
2858 | if (node->previous) | |
2859 | node->previous->next = node->next; | |
2860 | else | |
2861 | nodes = node->next; | |
2862 | ||
2863 | if (node->next) | |
2864 | node->next->previous = node->previous; | |
2865 | ||
2866 | node->next = NULL; | |
2867 | node->previous = NULL; | |
2868 | } | |
2869 | ||
3dafb85c ML |
2870 | /* Release a callgraph NODE with UID and put in to the list of free nodes. */ |
2871 | ||
2872 | inline void | |
74644756 | 2873 | symbol_table::release_symbol (cgraph_node *node) |
3dafb85c ML |
2874 | { |
2875 | cgraph_count--; | |
fe248a88 ML |
2876 | if (node->m_summary_id != -1) |
2877 | cgraph_released_summary_ids.safe_push (node->m_summary_id); | |
2878 | ggc_free (node); | |
3dafb85c ML |
2879 | } |
2880 | ||
3dafb85c ML |
2881 | /* Return first static symbol with definition. */ |
2882 | inline symtab_node * | |
2883 | symbol_table::first_symbol (void) | |
2884 | { | |
2885 | return nodes; | |
2886 | } | |
2887 | ||
1ab24192 JH |
2888 | /* Walk all symbols. */ |
2889 | #define FOR_EACH_SYMBOL(node) \ | |
3dafb85c | 2890 | for ((node) = symtab->first_symbol (); (node); (node) = (node)->next) |
1f00098b | 2891 | |
d6d229c6 | 2892 | /* Return first static symbol with definition. */ |
3dafb85c ML |
2893 | inline symtab_node * |
2894 | symbol_table::first_defined_symbol (void) | |
d6d229c6 JH |
2895 | { |
2896 | symtab_node *node; | |
2897 | ||
3dafb85c | 2898 | for (node = nodes; node; node = node->next) |
d6d229c6 JH |
2899 | if (node->definition) |
2900 | return node; | |
2901 | ||
2902 | return NULL; | |
2903 | } | |
2904 | ||
d6d229c6 JH |
2905 | /* Walk all symbols with definitions in current unit. */ |
2906 | #define FOR_EACH_DEFINED_SYMBOL(node) \ | |
3dafb85c | 2907 | for ((node) = symtab->first_defined_symbol (); (node); \ |
d52f5295 | 2908 | (node) = node->next_defined_symbol ()) |
66058468 JH |
2909 | |
2910 | /* Return first variable. */ | |
3dafb85c ML |
2911 | inline varpool_node * |
2912 | symbol_table::first_variable (void) | |
66058468 | 2913 | { |
5e20cdc9 | 2914 | symtab_node *node; |
3dafb85c | 2915 | for (node = nodes; node; node = node->next) |
7de90a6c | 2916 | if (varpool_node *vnode = dyn_cast <varpool_node *> (node)) |
5d59b5e1 | 2917 | return vnode; |
66058468 JH |
2918 | return NULL; |
2919 | } | |
2920 | ||
2921 | /* Return next variable after NODE. */ | |
3dafb85c ML |
2922 | inline varpool_node * |
2923 | symbol_table::next_variable (varpool_node *node) | |
66058468 | 2924 | { |
5e20cdc9 | 2925 | symtab_node *node1 = node->next; |
67348ccc | 2926 | for (; node1; node1 = node1->next) |
7de90a6c | 2927 | if (varpool_node *vnode1 = dyn_cast <varpool_node *> (node1)) |
5d59b5e1 | 2928 | return vnode1; |
66058468 JH |
2929 | return NULL; |
2930 | } | |
2931 | /* Walk all variables. */ | |
2932 | #define FOR_EACH_VARIABLE(node) \ | |
3dafb85c | 2933 | for ((node) = symtab->first_variable (); \ |
66058468 | 2934 | (node); \ |
3dafb85c | 2935 | (node) = symtab->next_variable ((node))) |
66058468 | 2936 | |
d6d229c6 | 2937 | /* Return first static variable with initializer. */ |
3dafb85c ML |
2938 | inline varpool_node * |
2939 | symbol_table::first_static_initializer (void) | |
68e56cc4 | 2940 | { |
5e20cdc9 | 2941 | symtab_node *node; |
3dafb85c | 2942 | for (node = nodes; node; node = node->next) |
68e56cc4 | 2943 | { |
7de90a6c | 2944 | varpool_node *vnode = dyn_cast <varpool_node *> (node); |
67348ccc | 2945 | if (vnode && DECL_INITIAL (node->decl)) |
5d59b5e1 | 2946 | return vnode; |
68e56cc4 JH |
2947 | } |
2948 | return NULL; | |
2949 | } | |
2950 | ||
d6d229c6 | 2951 | /* Return next static variable with initializer after NODE. */ |
3dafb85c ML |
2952 | inline varpool_node * |
2953 | symbol_table::next_static_initializer (varpool_node *node) | |
68e56cc4 | 2954 | { |
5e20cdc9 | 2955 | symtab_node *node1 = node->next; |
67348ccc | 2956 | for (; node1; node1 = node1->next) |
68e56cc4 | 2957 | { |
7de90a6c | 2958 | varpool_node *vnode1 = dyn_cast <varpool_node *> (node1); |
67348ccc | 2959 | if (vnode1 && DECL_INITIAL (node1->decl)) |
5d59b5e1 | 2960 | return vnode1; |
68e56cc4 JH |
2961 | } |
2962 | return NULL; | |
2963 | } | |
2964 | ||
2965 | /* Walk all static variables with initializer set. */ | |
2966 | #define FOR_EACH_STATIC_INITIALIZER(node) \ | |
3dafb85c ML |
2967 | for ((node) = symtab->first_static_initializer (); (node); \ |
2968 | (node) = symtab->next_static_initializer (node)) | |
2aae7680 | 2969 | |
d6d229c6 | 2970 | /* Return first static variable with definition. */ |
3dafb85c ML |
2971 | inline varpool_node * |
2972 | symbol_table::first_defined_variable (void) | |
2aae7680 | 2973 | { |
5e20cdc9 | 2974 | symtab_node *node; |
3dafb85c | 2975 | for (node = nodes; node; node = node->next) |
2aae7680 | 2976 | { |
7de90a6c | 2977 | varpool_node *vnode = dyn_cast <varpool_node *> (node); |
67348ccc | 2978 | if (vnode && vnode->definition) |
5d59b5e1 | 2979 | return vnode; |
2aae7680 JH |
2980 | } |
2981 | return NULL; | |
2982 | } | |
2983 | ||
d6d229c6 | 2984 | /* Return next static variable with definition after NODE. */ |
3dafb85c ML |
2985 | inline varpool_node * |
2986 | symbol_table::next_defined_variable (varpool_node *node) | |
2aae7680 | 2987 | { |
5e20cdc9 | 2988 | symtab_node *node1 = node->next; |
67348ccc | 2989 | for (; node1; node1 = node1->next) |
2aae7680 | 2990 | { |
7de90a6c | 2991 | varpool_node *vnode1 = dyn_cast <varpool_node *> (node1); |
67348ccc | 2992 | if (vnode1 && vnode1->definition) |
5d59b5e1 | 2993 | return vnode1; |
2aae7680 JH |
2994 | } |
2995 | return NULL; | |
2996 | } | |
65c70e6b JH |
2997 | /* Walk all variables with definitions in current unit. */ |
2998 | #define FOR_EACH_DEFINED_VARIABLE(node) \ | |
3dafb85c ML |
2999 | for ((node) = symtab->first_defined_variable (); (node); \ |
3000 | (node) = symtab->next_defined_variable (node)) | |
68e56cc4 | 3001 | |
c47d0034 | 3002 | /* Return first function with body defined. */ |
3dafb85c ML |
3003 | inline cgraph_node * |
3004 | symbol_table::first_defined_function (void) | |
c47d0034 | 3005 | { |
5e20cdc9 | 3006 | symtab_node *node; |
3dafb85c | 3007 | for (node = nodes; node; node = node->next) |
c47d0034 | 3008 | { |
7de90a6c | 3009 | cgraph_node *cn = dyn_cast <cgraph_node *> (node); |
67348ccc | 3010 | if (cn && cn->definition) |
5d59b5e1 | 3011 | return cn; |
c47d0034 JH |
3012 | } |
3013 | return NULL; | |
3014 | } | |
3015 | ||
45896127 | 3016 | /* Return next function with body defined after NODE. */ |
3dafb85c ML |
3017 | inline cgraph_node * |
3018 | symbol_table::next_defined_function (cgraph_node *node) | |
c47d0034 | 3019 | { |
5e20cdc9 | 3020 | symtab_node *node1 = node->next; |
67348ccc | 3021 | for (; node1; node1 = node1->next) |
c47d0034 | 3022 | { |
7de90a6c | 3023 | cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1); |
67348ccc | 3024 | if (cn1 && cn1->definition) |
5d59b5e1 | 3025 | return cn1; |
c47d0034 JH |
3026 | } |
3027 | return NULL; | |
3028 | } | |
3029 | ||
3030 | /* Walk all functions with body defined. */ | |
3031 | #define FOR_EACH_DEFINED_FUNCTION(node) \ | |
3dafb85c ML |
3032 | for ((node) = symtab->first_defined_function (); (node); \ |
3033 | (node) = symtab->next_defined_function ((node))) | |
2aae7680 JH |
3034 | |
3035 | /* Return first function. */ | |
3dafb85c ML |
3036 | inline cgraph_node * |
3037 | symbol_table::first_function (void) | |
2aae7680 | 3038 | { |
5e20cdc9 | 3039 | symtab_node *node; |
3dafb85c | 3040 | for (node = nodes; node; node = node->next) |
7de90a6c | 3041 | if (cgraph_node *cn = dyn_cast <cgraph_node *> (node)) |
5d59b5e1 | 3042 | return cn; |
2aae7680 JH |
3043 | return NULL; |
3044 | } | |
3045 | ||
3046 | /* Return next function. */ | |
3dafb85c ML |
3047 | inline cgraph_node * |
3048 | symbol_table::next_function (cgraph_node *node) | |
2aae7680 | 3049 | { |
5e20cdc9 | 3050 | symtab_node *node1 = node->next; |
67348ccc | 3051 | for (; node1; node1 = node1->next) |
7de90a6c | 3052 | if (cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1)) |
5d59b5e1 | 3053 | return cn1; |
2aae7680 JH |
3054 | return NULL; |
3055 | } | |
c47d0034 JH |
3056 | |
3057 | /* Return first function with body defined. */ | |
3dafb85c ML |
3058 | inline cgraph_node * |
3059 | symbol_table::first_function_with_gimple_body (void) | |
c47d0034 | 3060 | { |
5e20cdc9 | 3061 | symtab_node *node; |
3dafb85c | 3062 | for (node = nodes; node; node = node->next) |
c47d0034 | 3063 | { |
7de90a6c | 3064 | cgraph_node *cn = dyn_cast <cgraph_node *> (node); |
d52f5295 | 3065 | if (cn && cn->has_gimple_body_p ()) |
5d59b5e1 | 3066 | return cn; |
c47d0034 JH |
3067 | } |
3068 | return NULL; | |
3069 | } | |
3070 | ||
3071 | /* Return next reachable static variable with initializer after NODE. */ | |
3dafb85c ML |
3072 | inline cgraph_node * |
3073 | symbol_table::next_function_with_gimple_body (cgraph_node *node) | |
c47d0034 | 3074 | { |
5e20cdc9 | 3075 | symtab_node *node1 = node->next; |
67348ccc | 3076 | for (; node1; node1 = node1->next) |
c47d0034 | 3077 | { |
7de90a6c | 3078 | cgraph_node *cn1 = dyn_cast <cgraph_node *> (node1); |
d52f5295 | 3079 | if (cn1 && cn1->has_gimple_body_p ()) |
5d59b5e1 | 3080 | return cn1; |
c47d0034 JH |
3081 | } |
3082 | return NULL; | |
3083 | } | |
3084 | ||
3dafb85c ML |
3085 | /* Walk all functions. */ |
3086 | #define FOR_EACH_FUNCTION(node) \ | |
3087 | for ((node) = symtab->first_function (); (node); \ | |
3088 | (node) = symtab->next_function ((node))) | |
3089 | ||
3090 | /* Return true when callgraph node is a function with Gimple body defined | |
3091 | in current unit. Functions can also be define externally or they | |
3092 | can be thunks with no Gimple representation. | |
3093 | ||
3094 | Note that at WPA stage, the function body may not be present in memory. */ | |
3095 | ||
3096 | inline bool | |
3097 | cgraph_node::has_gimple_body_p (void) | |
3098 | { | |
3099 | return definition && !thunk.thunk_p && !alias; | |
3100 | } | |
3101 | ||
1738b522 MJ |
3102 | /* Return true if this node represents a former, i.e. an expanded, thunk. */ |
3103 | ||
3104 | inline bool | |
3105 | cgraph_node::former_thunk_p (void) | |
3106 | { | |
3107 | return (!thunk.thunk_p | |
3108 | && (thunk.fixed_offset | |
3109 | || thunk.virtual_offset_p | |
3110 | || thunk.indirect_offset)); | |
3111 | } | |
3112 | ||
c47d0034 JH |
3113 | /* Walk all functions with body defined. */ |
3114 | #define FOR_EACH_FUNCTION_WITH_GIMPLE_BODY(node) \ | |
3dafb85c ML |
3115 | for ((node) = symtab->first_function_with_gimple_body (); (node); \ |
3116 | (node) = symtab->next_function_with_gimple_body (node)) | |
c47d0034 | 3117 | |
d48e9cea OR |
3118 | /* Uniquize all constants that appear in memory. |
3119 | Each constant in memory thus far output is recorded | |
3120 | in `const_desc_table'. */ | |
3121 | ||
2a22f99c | 3122 | struct GTY((for_user)) constant_descriptor_tree { |
d48e9cea OR |
3123 | /* A MEM for the constant. */ |
3124 | rtx rtl; | |
b8698a0f | 3125 | |
d48e9cea OR |
3126 | /* The value of the constant. */ |
3127 | tree value; | |
3128 | ||
3129 | /* Hash of value. Computing the hash from value each time | |
3130 | hashfn is called can't work properly, as that means recursive | |
3131 | use of the hash table during hash table expansion. */ | |
3132 | hashval_t hash; | |
3133 | }; | |
3134 | ||
d52f5295 | 3135 | /* Return true when function is only called directly or it has alias. |
b20996ff JH |
3136 | i.e. it is not externally visible, address was not taken and |
3137 | it is not used in any other non-standard way. */ | |
3138 | ||
d52f5295 ML |
3139 | inline bool |
3140 | cgraph_node::only_called_directly_or_aliased_p (void) | |
3141 | { | |
a62bfab5 | 3142 | gcc_assert (!inlined_to); |
d52f5295 | 3143 | return (!force_output && !address_taken |
aab778d3 | 3144 | && !ifunc_resolver |
d52f5295 ML |
3145 | && !used_from_other_partition |
3146 | && !DECL_VIRTUAL_P (decl) | |
3147 | && !DECL_STATIC_CONSTRUCTOR (decl) | |
3148 | && !DECL_STATIC_DESTRUCTOR (decl) | |
a6a543bf | 3149 | && !used_from_object_file_p () |
d52f5295 | 3150 | && !externally_visible); |
b20996ff JH |
3151 | } |
3152 | ||
31de7606 JH |
3153 | /* Return true when function can be removed from callgraph |
3154 | if all direct calls are eliminated. */ | |
3155 | ||
3156 | inline bool | |
3157 | cgraph_node::can_remove_if_no_direct_calls_and_refs_p (void) | |
3158 | { | |
a62bfab5 | 3159 | gcc_checking_assert (!inlined_to); |
31de7606 JH |
3160 | /* Extern inlines can always go, we will use the external definition. */ |
3161 | if (DECL_EXTERNAL (decl)) | |
3162 | return true; | |
67914693 | 3163 | /* When function is needed, we cannot remove it. */ |
31de7606 JH |
3164 | if (force_output || used_from_other_partition) |
3165 | return false; | |
3166 | if (DECL_STATIC_CONSTRUCTOR (decl) | |
3167 | || DECL_STATIC_DESTRUCTOR (decl)) | |
3168 | return false; | |
3169 | /* Only COMDAT functions can be removed if externally visible. */ | |
3170 | if (externally_visible | |
b9dbb436 | 3171 | && ((!DECL_COMDAT (decl) || ifunc_resolver) |
31de7606 JH |
3172 | || forced_by_abi |
3173 | || used_from_object_file_p ())) | |
3174 | return false; | |
3175 | return true; | |
3176 | } | |
3177 | ||
b2b29377 MM |
3178 | /* Verify cgraph, if consistency checking is enabled. */ |
3179 | ||
3180 | inline void | |
3181 | cgraph_node::checking_verify_cgraph_nodes (void) | |
3182 | { | |
3183 | if (flag_checking) | |
3184 | cgraph_node::verify_cgraph_nodes (); | |
3185 | } | |
3186 | ||
9041d2e6 | 3187 | /* Return true when variable can be removed from variable pool |
df7705b1 JH |
3188 | if all direct calls are eliminated. */ |
3189 | ||
9041d2e6 ML |
3190 | inline bool |
3191 | varpool_node::can_remove_if_no_refs_p (void) | |
df7705b1 | 3192 | { |
9041d2e6 | 3193 | if (DECL_EXTERNAL (decl)) |
6649df51 | 3194 | return true; |
9041d2e6 ML |
3195 | return (!force_output && !used_from_other_partition |
3196 | && ((DECL_COMDAT (decl) | |
3197 | && !forced_by_abi | |
3198 | && !used_from_object_file_p ()) | |
3199 | || !externally_visible | |
3200 | || DECL_HAS_VALUE_EXPR_P (decl))); | |
df7705b1 JH |
3201 | } |
3202 | ||
9041d2e6 | 3203 | /* Return true when all references to variable must be visible in ipa_ref_list. |
4a444e58 JH |
3204 | i.e. if the variable is not externally visible or not used in some magic |
3205 | way (asm statement or such). | |
61502ca8 | 3206 | The magic uses are all summarized in force_output flag. */ |
4a444e58 | 3207 | |
9041d2e6 ML |
3208 | inline bool |
3209 | varpool_node::all_refs_explicit_p () | |
4a444e58 | 3210 | { |
9041d2e6 ML |
3211 | return (definition |
3212 | && !externally_visible | |
3213 | && !used_from_other_partition | |
3214 | && !force_output); | |
4a444e58 JH |
3215 | } |
3216 | ||
ca752f39 | 3217 | struct tree_descriptor_hasher : ggc_ptr_hash<constant_descriptor_tree> |
2a22f99c TS |
3218 | { |
3219 | static hashval_t hash (constant_descriptor_tree *); | |
3220 | static bool equal (constant_descriptor_tree *, constant_descriptor_tree *); | |
3221 | }; | |
3222 | ||
d48e9cea | 3223 | /* Constant pool accessor function. */ |
2a22f99c | 3224 | hash_table<tree_descriptor_hasher> *constant_pool_htab (void); |
fed5ae11 | 3225 | |
d52f5295 | 3226 | /* Return node that alias is aliasing. */ |
39e2db00 | 3227 | |
d52f5295 ML |
3228 | inline cgraph_node * |
3229 | cgraph_node::get_alias_target (void) | |
cd35bcf7 | 3230 | { |
d52f5295 | 3231 | return dyn_cast <cgraph_node *> (symtab_node::get_alias_target ()); |
cd35bcf7 JH |
3232 | } |
3233 | ||
9041d2e6 ML |
3234 | /* Return node that alias is aliasing. */ |
3235 | ||
3236 | inline varpool_node * | |
3237 | varpool_node::get_alias_target (void) | |
be330ed4 | 3238 | { |
9041d2e6 | 3239 | return dyn_cast <varpool_node *> (symtab_node::get_alias_target ()); |
be330ed4 JH |
3240 | } |
3241 | ||
31de7606 JH |
3242 | /* Walk the alias chain to return the symbol NODE is alias of. |
3243 | If NODE is not an alias, return NODE. | |
f13fe18b JH |
3244 | When AVAILABILITY is non-NULL, get minimal availability in the chain. |
3245 | When REF is non-NULL, assume that reference happens in symbol REF | |
3246 | when determining the availability. */ | |
31de7606 JH |
3247 | |
3248 | inline symtab_node * | |
f13fe18b JH |
3249 | symtab_node::ultimate_alias_target (enum availability *availability, |
3250 | symtab_node *ref) | |
31de7606 JH |
3251 | { |
3252 | if (!alias) | |
3253 | { | |
3254 | if (availability) | |
f13fe18b | 3255 | *availability = get_availability (ref); |
31de7606 JH |
3256 | return this; |
3257 | } | |
3258 | ||
f13fe18b | 3259 | return ultimate_alias_target_1 (availability, ref); |
31de7606 JH |
3260 | } |
3261 | ||
d52f5295 ML |
3262 | /* Given function symbol, walk the alias chain to return the function node |
3263 | is alias of. Do not walk through thunks. | |
f13fe18b JH |
3264 | When AVAILABILITY is non-NULL, get minimal availability in the chain. |
3265 | When REF is non-NULL, assume that reference happens in symbol REF | |
3266 | when determining the availability. */ | |
be330ed4 | 3267 | |
d52f5295 | 3268 | inline cgraph_node * |
f13fe18b JH |
3269 | cgraph_node::ultimate_alias_target (enum availability *availability, |
3270 | symtab_node *ref) | |
be330ed4 | 3271 | { |
31de7606 | 3272 | cgraph_node *n = dyn_cast <cgraph_node *> |
f13fe18b | 3273 | (symtab_node::ultimate_alias_target (availability, ref)); |
40a7fe1e | 3274 | if (!n && availability) |
39e2db00 | 3275 | *availability = AVAIL_NOT_AVAILABLE; |
e70670cf | 3276 | return n; |
be330ed4 | 3277 | } |
9041d2e6 ML |
3278 | |
3279 | /* For given variable pool node, walk the alias chain to return the function | |
3280 | the variable is alias of. Do not walk through thunks. | |
f13fe18b JH |
3281 | When AVAILABILITY is non-NULL, get minimal availability in the chain. |
3282 | When REF is non-NULL, assume that reference happens in symbol REF | |
3283 | when determining the availability. */ | |
cd35bcf7 | 3284 | |
9041d2e6 | 3285 | inline varpool_node * |
f13fe18b JH |
3286 | varpool_node::ultimate_alias_target (availability *availability, |
3287 | symtab_node *ref) | |
cd35bcf7 | 3288 | { |
9041d2e6 | 3289 | varpool_node *n = dyn_cast <varpool_node *> |
f13fe18b | 3290 | (symtab_node::ultimate_alias_target (availability, ref)); |
ff36fcbe | 3291 | |
40a7fe1e | 3292 | if (!n && availability) |
cd35bcf7 | 3293 | *availability = AVAIL_NOT_AVAILABLE; |
e70670cf | 3294 | return n; |
cd35bcf7 JH |
3295 | } |
3296 | ||
90988f77 ML |
3297 | /* Set callee N of call graph edge and add it to the corresponding set of |
3298 | callers. */ | |
3299 | ||
3300 | inline void | |
3301 | cgraph_edge::set_callee (cgraph_node *n) | |
3302 | { | |
3303 | prev_caller = NULL; | |
3304 | if (n->callers) | |
3305 | n->callers->prev_caller = this; | |
3306 | next_caller = n->callers; | |
3307 | n->callers = this; | |
3308 | callee = n; | |
3309 | } | |
3310 | ||
3dafb85c | 3311 | /* Return true when the edge represents a direct recursion. */ |
31de7606 | 3312 | |
3dafb85c ML |
3313 | inline bool |
3314 | cgraph_edge::recursive_p (void) | |
d7d1d041 | 3315 | { |
3dafb85c | 3316 | cgraph_node *c = callee->ultimate_alias_target (); |
a62bfab5 ML |
3317 | if (caller->inlined_to) |
3318 | return caller->inlined_to->decl == c->decl; | |
d7d1d041 | 3319 | else |
3dafb85c | 3320 | return caller->decl == c->decl; |
d7d1d041 | 3321 | } |
0a35513e | 3322 | |
90988f77 ML |
3323 | /* Remove the edge from the list of the callers of the callee. */ |
3324 | ||
3325 | inline void | |
3326 | cgraph_edge::remove_callee (void) | |
3327 | { | |
3328 | gcc_assert (!indirect_unknown_callee); | |
3329 | if (prev_caller) | |
3330 | prev_caller->next_caller = next_caller; | |
3331 | if (next_caller) | |
3332 | next_caller->prev_caller = prev_caller; | |
3333 | if (!prev_caller) | |
3334 | callee->callers = next_caller; | |
3335 | } | |
3336 | ||
f13fe18b JH |
3337 | /* Return true if call must bind to current definition. */ |
3338 | ||
3339 | inline bool | |
3340 | cgraph_edge::binds_to_current_def_p () | |
3341 | { | |
3342 | if (callee) | |
3343 | return callee->binds_to_current_def_p (caller); | |
3344 | else | |
aff98801 | 3345 | return false; |
f13fe18b JH |
3346 | } |
3347 | ||
1bad9c18 JH |
3348 | /* Expected frequency of executions within the function. |
3349 | When set to CGRAPH_FREQ_BASE, the edge is expected to be called once | |
3350 | per function call. The range is 0 to CGRAPH_FREQ_MAX. */ | |
3351 | ||
3352 | inline int | |
3353 | cgraph_edge::frequency () | |
3354 | { | |
a62bfab5 ML |
3355 | return count.to_cgraph_frequency (caller->inlined_to |
3356 | ? caller->inlined_to->count | |
1bad9c18 JH |
3357 | : caller->count); |
3358 | } | |
3359 | ||
41f0e819 | 3360 | |
0a35513e AH |
3361 | /* Return true if the TM_CLONE bit is set for a given FNDECL. */ |
3362 | static inline bool | |
3363 | decl_is_tm_clone (const_tree fndecl) | |
3364 | { | |
d52f5295 | 3365 | cgraph_node *n = cgraph_node::get (fndecl); |
0a35513e AH |
3366 | if (n) |
3367 | return n->tm_clone; | |
3368 | return false; | |
3369 | } | |
9c8305f8 JH |
3370 | |
3371 | /* Likewise indicate that a node is needed, i.e. reachable via some | |
3372 | external means. */ | |
3373 | ||
d52f5295 ML |
3374 | inline void |
3375 | cgraph_node::mark_force_output (void) | |
1f26ac87 | 3376 | { |
d52f5295 | 3377 | force_output = 1; |
a62bfab5 | 3378 | gcc_checking_assert (!inlined_to); |
1f26ac87 JM |
3379 | } |
3380 | ||
893479de AM |
3381 | /* Return true if function should be optimized for size. */ |
3382 | ||
3383 | inline bool | |
3384 | cgraph_node::optimize_for_size_p (void) | |
3385 | { | |
b065b669 | 3386 | if (opt_for_fn (decl, optimize_size)) |
893479de AM |
3387 | return true; |
3388 | if (frequency == NODE_FREQUENCY_UNLIKELY_EXECUTED) | |
3389 | return true; | |
3390 | else | |
3391 | return false; | |
3392 | } | |
3393 | ||
31de7606 JH |
3394 | /* Return symtab_node for NODE or create one if it is not present |
3395 | in symtab. */ | |
3396 | ||
3397 | inline symtab_node * | |
3398 | symtab_node::get_create (tree node) | |
f7217cde JH |
3399 | { |
3400 | if (TREE_CODE (node) == VAR_DECL) | |
3401 | return varpool_node::get_create (node); | |
3402 | else | |
3403 | return cgraph_node::get_create (node); | |
3404 | } | |
3405 | ||
f13fe18b | 3406 | /* Return availability of NODE when referenced from REF. */ |
31de7606 JH |
3407 | |
3408 | inline enum availability | |
f13fe18b | 3409 | symtab_node::get_availability (symtab_node *ref) |
31de7606 JH |
3410 | { |
3411 | if (is_a <cgraph_node *> (this)) | |
f13fe18b | 3412 | return dyn_cast <cgraph_node *> (this)->get_availability (ref); |
31de7606 | 3413 | else |
f13fe18b | 3414 | return dyn_cast <varpool_node *> (this)->get_availability (ref); |
31de7606 JH |
3415 | } |
3416 | ||
dfea3d6f | 3417 | /* Call callback on symtab node and aliases associated to this node. |
6b715bf6 | 3418 | When INCLUDE_OVERWRITABLE is false, overwritable symbols are skipped. */ |
31de7606 JH |
3419 | |
3420 | inline bool | |
3421 | symtab_node::call_for_symbol_and_aliases (bool (*callback) (symtab_node *, | |
3422 | void *), | |
3423 | void *data, | |
3424 | bool include_overwritable) | |
3425 | { | |
6b715bf6 JH |
3426 | if (include_overwritable |
3427 | || get_availability () > AVAIL_INTERPOSABLE) | |
3428 | { | |
3429 | if (callback (this, data)) | |
3430 | return true; | |
3431 | } | |
190bbd0b | 3432 | if (has_aliases_p ()) |
31de7606 JH |
3433 | return call_for_symbol_and_aliases_1 (callback, data, include_overwritable); |
3434 | return false; | |
3435 | } | |
3436 | ||
3437 | /* Call callback on function and aliases associated to the function. | |
6b715bf6 | 3438 | When INCLUDE_OVERWRITABLE is false, overwritable symbols are |
31de7606 JH |
3439 | skipped. */ |
3440 | ||
3441 | inline bool | |
3442 | cgraph_node::call_for_symbol_and_aliases (bool (*callback) (cgraph_node *, | |
3443 | void *), | |
3444 | void *data, | |
3445 | bool include_overwritable) | |
3446 | { | |
6b715bf6 JH |
3447 | if (include_overwritable |
3448 | || get_availability () > AVAIL_INTERPOSABLE) | |
3449 | { | |
3450 | if (callback (this, data)) | |
3451 | return true; | |
3452 | } | |
190bbd0b | 3453 | if (has_aliases_p ()) |
31de7606 | 3454 | return call_for_symbol_and_aliases_1 (callback, data, include_overwritable); |
31de7606 JH |
3455 | return false; |
3456 | } | |
3457 | ||
dfea3d6f | 3458 | /* Call callback on varpool symbol and aliases associated to varpool symbol. |
6b715bf6 | 3459 | When INCLUDE_OVERWRITABLE is false, overwritable symbols are |
31de7606 JH |
3460 | skipped. */ |
3461 | ||
3462 | inline bool | |
3463 | varpool_node::call_for_symbol_and_aliases (bool (*callback) (varpool_node *, | |
3464 | void *), | |
3465 | void *data, | |
3466 | bool include_overwritable) | |
3467 | { | |
6b715bf6 JH |
3468 | if (include_overwritable |
3469 | || get_availability () > AVAIL_INTERPOSABLE) | |
3470 | { | |
3471 | if (callback (this, data)) | |
3472 | return true; | |
3473 | } | |
190bbd0b | 3474 | if (has_aliases_p ()) |
31de7606 | 3475 | return call_for_symbol_and_aliases_1 (callback, data, include_overwritable); |
31de7606 JH |
3476 | return false; |
3477 | } | |
3478 | ||
dfea3d6f | 3479 | /* Return true if reference may be used in address compare. */ |
0a7246ee JH |
3480 | |
3481 | inline bool | |
3482 | ipa_ref::address_matters_p () | |
3483 | { | |
3484 | if (use != IPA_REF_ADDR) | |
3485 | return false; | |
3486 | /* Addresses taken from virtual tables are never compared. */ | |
3487 | if (is_a <varpool_node *> (referring) | |
3488 | && DECL_VIRTUAL_P (referring->decl)) | |
3489 | return false; | |
3490 | return referred->address_can_be_compared_p (); | |
3491 | } | |
3492 | ||
ba392339 JH |
3493 | /* Build polymorphic call context for indirect call E. */ |
3494 | ||
3495 | inline | |
3496 | ipa_polymorphic_call_context::ipa_polymorphic_call_context (cgraph_edge *e) | |
3497 | { | |
3498 | gcc_checking_assert (e->indirect_info->polymorphic); | |
3499 | *this = e->indirect_info->context; | |
3500 | } | |
3501 | ||
3502 | /* Build empty "I know nothing" context. */ | |
3503 | ||
3504 | inline | |
3505 | ipa_polymorphic_call_context::ipa_polymorphic_call_context () | |
3506 | { | |
3507 | clear_speculation (); | |
3508 | clear_outer_type (); | |
3509 | invalid = false; | |
3510 | } | |
3511 | ||
3512 | /* Make context non-speculative. */ | |
3513 | ||
3514 | inline void | |
3515 | ipa_polymorphic_call_context::clear_speculation () | |
3516 | { | |
3517 | speculative_outer_type = NULL; | |
3518 | speculative_offset = 0; | |
3519 | speculative_maybe_derived_type = false; | |
3520 | } | |
3521 | ||
dfea3d6f | 3522 | /* Produce context specifying all derived types of OTR_TYPE. If OTR_TYPE is |
6ff65dd7 | 3523 | NULL, the context is set to dummy "I know nothing" setting. */ |
ba392339 JH |
3524 | |
3525 | inline void | |
3526 | ipa_polymorphic_call_context::clear_outer_type (tree otr_type) | |
3527 | { | |
3528 | outer_type = otr_type ? TYPE_MAIN_VARIANT (otr_type) : NULL; | |
3529 | offset = 0; | |
3530 | maybe_derived_type = true; | |
3531 | maybe_in_construction = true; | |
4081ada2 | 3532 | dynamic = true; |
ba392339 | 3533 | } |
67a1b94c JH |
3534 | |
3535 | /* Adjust all offsets in contexts by OFF bits. */ | |
3536 | ||
3537 | inline void | |
3538 | ipa_polymorphic_call_context::offset_by (HOST_WIDE_INT off) | |
3539 | { | |
3540 | if (outer_type) | |
3541 | offset += off; | |
3542 | if (speculative_outer_type) | |
3543 | speculative_offset += off; | |
3544 | } | |
3545 | ||
3546 | /* Return TRUE if context is fully useless. */ | |
3547 | ||
3548 | inline bool | |
3549 | ipa_polymorphic_call_context::useless_p () const | |
3550 | { | |
3551 | return (!outer_type && !speculative_outer_type); | |
3552 | } | |
d5e254e1 | 3553 | |
2a72a953 DM |
3554 | /* When using fprintf (or similar), problems can arise with |
3555 | transient generated strings. Many string-generation APIs | |
3556 | only support one result being alive at once (e.g. by | |
3557 | returning a pointer to a statically-allocated buffer). | |
3558 | ||
3559 | If there is more than one generated string within one | |
3560 | fprintf call: the first string gets evicted or overwritten | |
3561 | by the second, before fprintf is fully evaluated. | |
3562 | See e.g. PR/53136. | |
3563 | ||
3564 | This function provides a workaround for this, by providing | |
3565 | a simple way to create copies of these transient strings, | |
3566 | without the need to have explicit cleanup: | |
3567 | ||
3568 | fprintf (dumpfile, "string 1: %s string 2:%s\n", | |
3569 | xstrdup_for_dump (EXPR_1), | |
3570 | xstrdup_for_dump (EXPR_2)); | |
3571 | ||
3572 | This is actually a simple wrapper around ggc_strdup, but | |
3573 | the name documents the intent. We require that no GC can occur | |
3574 | within the fprintf call. */ | |
3575 | ||
3576 | static inline const char * | |
3577 | xstrdup_for_dump (const char *transient_str) | |
3578 | { | |
3579 | return ggc_strdup (transient_str); | |
3580 | } | |
3581 | ||
f714ecf5 JH |
3582 | /* During LTO stream-in this predicate can be used to check whether node |
3583 | in question prevails in the linking to save some memory usage. */ | |
3584 | inline bool | |
3585 | symtab_node::prevailing_p (void) | |
3586 | { | |
3587 | return definition && ((!TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl)) | |
3588 | || previous_sharing_asm_name == NULL); | |
3589 | } | |
3590 | ||
212755ff DM |
3591 | extern GTY(()) symbol_table *saved_symtab; |
3592 | ||
3593 | #if CHECKING_P | |
3594 | ||
3595 | namespace selftest { | |
3596 | ||
3597 | /* An RAII-style class for use in selftests for temporarily using a different | |
3598 | symbol_table, so that such tests can be isolated from each other. */ | |
3599 | ||
3600 | class symbol_table_test | |
3601 | { | |
3602 | public: | |
3603 | /* Constructor. Override "symtab". */ | |
3604 | symbol_table_test (); | |
3605 | ||
3606 | /* Destructor. Restore the saved_symtab. */ | |
3607 | ~symbol_table_test (); | |
3608 | }; | |
3609 | ||
3610 | } // namespace selftest | |
3611 | ||
3612 | #endif /* CHECKING_P */ | |
3613 | ||
1c4a429a | 3614 | #endif /* GCC_CGRAPH_H */ |