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