|
111
|
1 /* Symbol table.
|
|
145
|
2 Copyright (C) 2012-2020 Free Software Foundation, Inc.
|
|
111
|
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 #include "config.h"
|
|
|
22 #include "system.h"
|
|
|
23 #include "coretypes.h"
|
|
|
24 #include "backend.h"
|
|
|
25 #include "target.h"
|
|
|
26 #include "rtl.h"
|
|
|
27 #include "tree.h"
|
|
|
28 #include "gimple.h"
|
|
|
29 #include "timevar.h"
|
|
|
30 #include "cgraph.h"
|
|
|
31 #include "lto-streamer.h"
|
|
|
32 #include "print-tree.h"
|
|
|
33 #include "varasm.h"
|
|
|
34 #include "langhooks.h"
|
|
|
35 #include "output.h"
|
|
|
36 #include "ipa-utils.h"
|
|
|
37 #include "calls.h"
|
|
|
38 #include "stringpool.h"
|
|
|
39 #include "attribs.h"
|
|
131
|
40 #include "builtins.h"
|
|
111
|
41
|
|
131
|
42 static const char *ipa_ref_use_name[] = {"read","write","addr","alias"};
|
|
111
|
43
|
|
|
44 const char * const ld_plugin_symbol_resolution_names[]=
|
|
|
45 {
|
|
|
46 "",
|
|
|
47 "undef",
|
|
|
48 "prevailing_def",
|
|
|
49 "prevailing_def_ironly",
|
|
|
50 "preempted_reg",
|
|
|
51 "preempted_ir",
|
|
|
52 "resolved_ir",
|
|
|
53 "resolved_exec",
|
|
|
54 "resolved_dyn",
|
|
|
55 "prevailing_def_ironly_exp"
|
|
|
56 };
|
|
|
57
|
|
|
58 /* Follow the IDENTIFIER_TRANSPARENT_ALIAS chain starting at ALIAS
|
|
|
59 until we find an identifier that is not itself a transparent alias. */
|
|
|
60
|
|
|
61 static inline tree
|
|
|
62 ultimate_transparent_alias_target (tree alias)
|
|
|
63 {
|
|
|
64 tree target = alias;
|
|
|
65
|
|
|
66 while (IDENTIFIER_TRANSPARENT_ALIAS (target))
|
|
|
67 {
|
|
|
68 gcc_checking_assert (TREE_CHAIN (target));
|
|
|
69 target = TREE_CHAIN (target);
|
|
|
70 }
|
|
|
71 gcc_checking_assert (! IDENTIFIER_TRANSPARENT_ALIAS (target)
|
|
|
72 && ! TREE_CHAIN (target));
|
|
|
73
|
|
|
74 return target;
|
|
|
75 }
|
|
|
76
|
|
|
77
|
|
|
78 /* Hash asmnames ignoring the user specified marks. */
|
|
|
79
|
|
|
80 hashval_t
|
|
|
81 symbol_table::decl_assembler_name_hash (const_tree asmname)
|
|
|
82 {
|
|
|
83 if (IDENTIFIER_POINTER (asmname)[0] == '*')
|
|
|
84 {
|
|
|
85 const char *decl_str = IDENTIFIER_POINTER (asmname) + 1;
|
|
|
86 size_t ulp_len = strlen (user_label_prefix);
|
|
|
87
|
|
|
88 if (ulp_len == 0)
|
|
|
89 ;
|
|
|
90 else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0)
|
|
|
91 decl_str += ulp_len;
|
|
|
92
|
|
|
93 return htab_hash_string (decl_str);
|
|
|
94 }
|
|
|
95
|
|
|
96 return htab_hash_string (IDENTIFIER_POINTER (asmname));
|
|
|
97 }
|
|
|
98
|
|
|
99 /* Return true if assembler names NAME1 and NAME2 leads to the same symbol
|
|
|
100 name. */
|
|
|
101
|
|
|
102 bool
|
|
|
103 symbol_table::assembler_names_equal_p (const char *name1, const char *name2)
|
|
|
104 {
|
|
|
105 if (name1 != name2)
|
|
|
106 {
|
|
|
107 if (name1[0] == '*')
|
|
|
108 {
|
|
|
109 size_t ulp_len = strlen (user_label_prefix);
|
|
|
110
|
|
|
111 name1 ++;
|
|
|
112
|
|
|
113 if (ulp_len == 0)
|
|
|
114 ;
|
|
|
115 else if (strncmp (name1, user_label_prefix, ulp_len) == 0)
|
|
|
116 name1 += ulp_len;
|
|
|
117 else
|
|
|
118 return false;
|
|
|
119 }
|
|
|
120 if (name2[0] == '*')
|
|
|
121 {
|
|
|
122 size_t ulp_len = strlen (user_label_prefix);
|
|
|
123
|
|
|
124 name2 ++;
|
|
|
125
|
|
|
126 if (ulp_len == 0)
|
|
|
127 ;
|
|
|
128 else if (strncmp (name2, user_label_prefix, ulp_len) == 0)
|
|
|
129 name2 += ulp_len;
|
|
|
130 else
|
|
|
131 return false;
|
|
|
132 }
|
|
|
133 return !strcmp (name1, name2);
|
|
|
134 }
|
|
|
135 return true;
|
|
|
136 }
|
|
|
137
|
|
|
138 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */
|
|
|
139
|
|
|
140 bool
|
|
|
141 symbol_table::decl_assembler_name_equal (tree decl, const_tree asmname)
|
|
|
142 {
|
|
|
143 tree decl_asmname = DECL_ASSEMBLER_NAME (decl);
|
|
|
144 const char *decl_str;
|
|
|
145 const char *asmname_str;
|
|
|
146
|
|
|
147 if (decl_asmname == asmname)
|
|
|
148 return true;
|
|
|
149
|
|
|
150 decl_str = IDENTIFIER_POINTER (decl_asmname);
|
|
|
151 asmname_str = IDENTIFIER_POINTER (asmname);
|
|
|
152 return assembler_names_equal_p (decl_str, asmname_str);
|
|
|
153 }
|
|
|
154
|
|
|
155
|
|
|
156 /* Returns nonzero if P1 and P2 are equal. */
|
|
|
157
|
|
|
158 /* Insert NODE to assembler name hash. */
|
|
|
159
|
|
|
160 void
|
|
|
161 symbol_table::insert_to_assembler_name_hash (symtab_node *node,
|
|
|
162 bool with_clones)
|
|
|
163 {
|
|
|
164 if (is_a <varpool_node *> (node) && DECL_HARD_REGISTER (node->decl))
|
|
|
165 return;
|
|
|
166 gcc_checking_assert (!node->previous_sharing_asm_name
|
|
|
167 && !node->next_sharing_asm_name);
|
|
|
168 if (assembler_name_hash)
|
|
|
169 {
|
|
|
170 symtab_node **aslot;
|
|
|
171 cgraph_node *cnode;
|
|
|
172 tree decl = node->decl;
|
|
|
173
|
|
|
174 tree name = DECL_ASSEMBLER_NAME (node->decl);
|
|
|
175
|
|
|
176 /* C++ FE can produce decls without associated assembler name and insert
|
|
|
177 them to symtab to hold section or TLS information. */
|
|
|
178 if (!name)
|
|
|
179 return;
|
|
|
180
|
|
|
181 hashval_t hash = decl_assembler_name_hash (name);
|
|
|
182 aslot = assembler_name_hash->find_slot_with_hash (name, hash, INSERT);
|
|
|
183 gcc_assert (*aslot != node);
|
|
|
184 node->next_sharing_asm_name = (symtab_node *)*aslot;
|
|
|
185 if (*aslot != NULL)
|
|
|
186 (*aslot)->previous_sharing_asm_name = node;
|
|
|
187 *aslot = node;
|
|
|
188
|
|
|
189 /* Update also possible inline clones sharing a decl. */
|
|
|
190 cnode = dyn_cast <cgraph_node *> (node);
|
|
|
191 if (cnode && cnode->clones && with_clones)
|
|
|
192 for (cnode = cnode->clones; cnode; cnode = cnode->next_sibling_clone)
|
|
|
193 if (cnode->decl == decl)
|
|
|
194 insert_to_assembler_name_hash (cnode, true);
|
|
|
195 }
|
|
|
196
|
|
|
197 }
|
|
|
198
|
|
|
199 /* Remove NODE from assembler name hash. */
|
|
|
200
|
|
|
201 void
|
|
|
202 symbol_table::unlink_from_assembler_name_hash (symtab_node *node,
|
|
|
203 bool with_clones)
|
|
|
204 {
|
|
|
205 if (assembler_name_hash)
|
|
|
206 {
|
|
|
207 cgraph_node *cnode;
|
|
|
208 tree decl = node->decl;
|
|
|
209
|
|
|
210 if (node->next_sharing_asm_name)
|
|
|
211 node->next_sharing_asm_name->previous_sharing_asm_name
|
|
|
212 = node->previous_sharing_asm_name;
|
|
|
213 if (node->previous_sharing_asm_name)
|
|
|
214 {
|
|
|
215 node->previous_sharing_asm_name->next_sharing_asm_name
|
|
|
216 = node->next_sharing_asm_name;
|
|
|
217 }
|
|
|
218 else
|
|
|
219 {
|
|
|
220 tree name = DECL_ASSEMBLER_NAME (node->decl);
|
|
|
221 symtab_node **slot;
|
|
|
222
|
|
|
223 if (!name)
|
|
|
224 return;
|
|
|
225
|
|
|
226 hashval_t hash = decl_assembler_name_hash (name);
|
|
|
227 slot = assembler_name_hash->find_slot_with_hash (name, hash,
|
|
|
228 NO_INSERT);
|
|
|
229 gcc_assert (*slot == node);
|
|
|
230 if (!node->next_sharing_asm_name)
|
|
|
231 assembler_name_hash->clear_slot (slot);
|
|
|
232 else
|
|
|
233 *slot = node->next_sharing_asm_name;
|
|
|
234 }
|
|
|
235 node->next_sharing_asm_name = NULL;
|
|
|
236 node->previous_sharing_asm_name = NULL;
|
|
|
237
|
|
|
238 /* Update also possible inline clones sharing a decl. */
|
|
|
239 cnode = dyn_cast <cgraph_node *> (node);
|
|
|
240 if (cnode && cnode->clones && with_clones)
|
|
|
241 for (cnode = cnode->clones; cnode; cnode = cnode->next_sibling_clone)
|
|
|
242 if (cnode->decl == decl)
|
|
|
243 unlink_from_assembler_name_hash (cnode, true);
|
|
|
244 }
|
|
|
245 }
|
|
|
246
|
|
|
247 /* Arrange node to be first in its entry of assembler_name_hash. */
|
|
|
248
|
|
|
249 void
|
|
|
250 symbol_table::symtab_prevail_in_asm_name_hash (symtab_node *node)
|
|
|
251 {
|
|
|
252 unlink_from_assembler_name_hash (node, false);
|
|
|
253 insert_to_assembler_name_hash (node, false);
|
|
|
254 }
|
|
|
255
|
|
145
|
256 /* Initialize asm name hash unless. */
|
|
111
|
257
|
|
|
258 void
|
|
|
259 symbol_table::symtab_initialize_asm_name_hash (void)
|
|
|
260 {
|
|
|
261 symtab_node *node;
|
|
|
262 if (!assembler_name_hash)
|
|
|
263 {
|
|
|
264 assembler_name_hash = hash_table<asmname_hasher>::create_ggc (10);
|
|
|
265 FOR_EACH_SYMBOL (node)
|
|
|
266 insert_to_assembler_name_hash (node, false);
|
|
|
267 }
|
|
|
268 }
|
|
|
269
|
|
|
270 /* Set the DECL_ASSEMBLER_NAME and update symtab hashtables. */
|
|
|
271
|
|
|
272 void
|
|
|
273 symbol_table::change_decl_assembler_name (tree decl, tree name)
|
|
|
274 {
|
|
|
275 symtab_node *node = NULL;
|
|
|
276
|
|
|
277 /* We can have user ASM names on things, like global register variables, that
|
|
|
278 are not in the symbol table. */
|
|
|
279 if ((VAR_P (decl) && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
|
|
|
280 || TREE_CODE (decl) == FUNCTION_DECL)
|
|
|
281 node = symtab_node::get (decl);
|
|
|
282 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
|
|
|
283 {
|
|
|
284 SET_DECL_ASSEMBLER_NAME (decl, name);
|
|
|
285 if (node)
|
|
|
286 insert_to_assembler_name_hash (node, true);
|
|
|
287 }
|
|
|
288 else
|
|
|
289 {
|
|
|
290 if (name == DECL_ASSEMBLER_NAME (decl))
|
|
|
291 return;
|
|
|
292
|
|
|
293 tree alias = (IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl))
|
|
|
294 ? TREE_CHAIN (DECL_ASSEMBLER_NAME (decl))
|
|
|
295 : NULL);
|
|
|
296 if (node)
|
|
|
297 unlink_from_assembler_name_hash (node, true);
|
|
|
298
|
|
|
299 const char *old_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
|
|
|
300 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
|
|
|
301 && DECL_RTL_SET_P (decl))
|
|
|
302 warning (0, "%qD renamed after being referenced in assembly", decl);
|
|
|
303
|
|
|
304 SET_DECL_ASSEMBLER_NAME (decl, name);
|
|
|
305 if (alias)
|
|
|
306 {
|
|
|
307 IDENTIFIER_TRANSPARENT_ALIAS (name) = 1;
|
|
|
308 TREE_CHAIN (name) = alias;
|
|
|
309 }
|
|
|
310 /* If we change assembler name, also all transparent aliases must
|
|
|
311 be updated. There are three kinds - those having same assembler name,
|
|
|
312 those being renamed in varasm.c and weakref being renamed by the
|
|
|
313 assembler. */
|
|
|
314 if (node)
|
|
|
315 {
|
|
|
316 insert_to_assembler_name_hash (node, true);
|
|
|
317 ipa_ref *ref;
|
|
|
318 for (unsigned i = 0; node->iterate_direct_aliases (i, ref); i++)
|
|
|
319 {
|
|
|
320 struct symtab_node *alias = ref->referring;
|
|
|
321 if (alias->transparent_alias && !alias->weakref
|
|
|
322 && symbol_table::assembler_names_equal_p
|
|
|
323 (old_name, IDENTIFIER_POINTER (
|
|
|
324 DECL_ASSEMBLER_NAME (alias->decl))))
|
|
|
325 change_decl_assembler_name (alias->decl, name);
|
|
|
326 else if (alias->transparent_alias
|
|
|
327 && IDENTIFIER_TRANSPARENT_ALIAS (alias->decl))
|
|
|
328 {
|
|
|
329 gcc_assert (TREE_CHAIN (DECL_ASSEMBLER_NAME (alias->decl))
|
|
|
330 && IDENTIFIER_TRANSPARENT_ALIAS
|
|
|
331 (DECL_ASSEMBLER_NAME (alias->decl)));
|
|
|
332
|
|
|
333 TREE_CHAIN (DECL_ASSEMBLER_NAME (alias->decl)) =
|
|
|
334 ultimate_transparent_alias_target
|
|
|
335 (DECL_ASSEMBLER_NAME (node->decl));
|
|
|
336 }
|
|
|
337 #ifdef ASM_OUTPUT_WEAKREF
|
|
|
338 else gcc_assert (!alias->transparent_alias || alias->weakref);
|
|
|
339 #else
|
|
|
340 else gcc_assert (!alias->transparent_alias);
|
|
|
341 #endif
|
|
|
342 }
|
|
|
343 gcc_assert (!node->transparent_alias || !node->definition
|
|
|
344 || node->weakref
|
|
|
345 || TREE_CHAIN (DECL_ASSEMBLER_NAME (decl))
|
|
|
346 || symbol_table::assembler_names_equal_p
|
|
|
347 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
|
|
|
348 IDENTIFIER_POINTER
|
|
|
349 (DECL_ASSEMBLER_NAME
|
|
|
350 (node->get_alias_target ()->decl))));
|
|
|
351 }
|
|
|
352 }
|
|
|
353 }
|
|
|
354
|
|
|
355 /* Hash sections by their names. */
|
|
|
356
|
|
|
357 hashval_t
|
|
|
358 section_name_hasher::hash (section_hash_entry *n)
|
|
|
359 {
|
|
|
360 return htab_hash_string (n->name);
|
|
|
361 }
|
|
|
362
|
|
|
363 /* Return true if section P1 name equals to P2. */
|
|
|
364
|
|
|
365 bool
|
|
|
366 section_name_hasher::equal (section_hash_entry *n1, const char *name)
|
|
|
367 {
|
|
|
368 return n1->name == name || !strcmp (n1->name, name);
|
|
|
369 }
|
|
|
370
|
|
|
371 /* Add node into symbol table. This function is not used directly, but via
|
|
|
372 cgraph/varpool node creation routines. */
|
|
|
373
|
|
|
374 void
|
|
|
375 symtab_node::register_symbol (void)
|
|
|
376 {
|
|
|
377 symtab->register_symbol (this);
|
|
|
378
|
|
|
379 if (!decl->decl_with_vis.symtab_node)
|
|
|
380 decl->decl_with_vis.symtab_node = this;
|
|
|
381
|
|
|
382 ref_list.clear ();
|
|
|
383
|
|
|
384 /* Be sure to do this last; C++ FE might create new nodes via
|
|
|
385 DECL_ASSEMBLER_NAME langhook! */
|
|
|
386 symtab->insert_to_assembler_name_hash (this, false);
|
|
|
387 }
|
|
|
388
|
|
|
389 /* Remove NODE from same comdat group. */
|
|
|
390
|
|
|
391 void
|
|
|
392 symtab_node::remove_from_same_comdat_group (void)
|
|
|
393 {
|
|
|
394 if (same_comdat_group)
|
|
|
395 {
|
|
|
396 symtab_node *prev;
|
|
|
397 for (prev = same_comdat_group;
|
|
|
398 prev->same_comdat_group != this;
|
|
|
399 prev = prev->same_comdat_group)
|
|
|
400 ;
|
|
|
401 if (same_comdat_group == prev)
|
|
|
402 prev->same_comdat_group = NULL;
|
|
|
403 else
|
|
|
404 prev->same_comdat_group = same_comdat_group;
|
|
|
405 same_comdat_group = NULL;
|
|
|
406 set_comdat_group (NULL);
|
|
|
407 }
|
|
|
408 }
|
|
|
409
|
|
|
410 /* Remove node from symbol table. This function is not used directly, but via
|
|
|
411 cgraph/varpool node removal routines. */
|
|
|
412
|
|
|
413 void
|
|
|
414 symtab_node::unregister (void)
|
|
|
415 {
|
|
|
416 remove_all_references ();
|
|
|
417 remove_all_referring ();
|
|
|
418
|
|
|
419 /* Remove reference to section. */
|
|
|
420 set_section_for_node (NULL);
|
|
|
421
|
|
|
422 remove_from_same_comdat_group ();
|
|
|
423
|
|
|
424 symtab->unregister (this);
|
|
|
425
|
|
|
426 /* During LTO symtab merging we temporarily corrupt decl to symtab node
|
|
|
427 hash. */
|
|
|
428 gcc_assert (decl->decl_with_vis.symtab_node || in_lto_p);
|
|
|
429 if (decl->decl_with_vis.symtab_node == this)
|
|
|
430 {
|
|
|
431 symtab_node *replacement_node = NULL;
|
|
|
432 if (cgraph_node *cnode = dyn_cast <cgraph_node *> (this))
|
|
|
433 replacement_node = cnode->find_replacement ();
|
|
|
434 decl->decl_with_vis.symtab_node = replacement_node;
|
|
|
435 }
|
|
|
436 if (!is_a <varpool_node *> (this) || !DECL_HARD_REGISTER (decl))
|
|
|
437 symtab->unlink_from_assembler_name_hash (this, false);
|
|
|
438 if (in_init_priority_hash)
|
|
|
439 symtab->init_priority_hash->remove (this);
|
|
|
440 }
|
|
|
441
|
|
|
442
|
|
|
443 /* Remove symbol from symbol table. */
|
|
|
444
|
|
|
445 void
|
|
|
446 symtab_node::remove (void)
|
|
|
447 {
|
|
|
448 if (cgraph_node *cnode = dyn_cast <cgraph_node *> (this))
|
|
|
449 cnode->remove ();
|
|
|
450 else if (varpool_node *vnode = dyn_cast <varpool_node *> (this))
|
|
|
451 vnode->remove ();
|
|
|
452 }
|
|
|
453
|
|
|
454 /* Add NEW_ to the same comdat group that OLD is in. */
|
|
|
455
|
|
|
456 void
|
|
|
457 symtab_node::add_to_same_comdat_group (symtab_node *old_node)
|
|
|
458 {
|
|
|
459 gcc_assert (old_node->get_comdat_group ());
|
|
|
460 gcc_assert (!same_comdat_group);
|
|
|
461 gcc_assert (this != old_node);
|
|
|
462
|
|
|
463 set_comdat_group (old_node->get_comdat_group ());
|
|
|
464 same_comdat_group = old_node;
|
|
|
465 if (!old_node->same_comdat_group)
|
|
|
466 old_node->same_comdat_group = this;
|
|
|
467 else
|
|
|
468 {
|
|
|
469 symtab_node *n;
|
|
|
470 for (n = old_node->same_comdat_group;
|
|
|
471 n->same_comdat_group != old_node;
|
|
|
472 n = n->same_comdat_group)
|
|
|
473 ;
|
|
|
474 n->same_comdat_group = this;
|
|
|
475 }
|
|
|
476 }
|
|
|
477
|
|
|
478 /* Dissolve the same_comdat_group list in which NODE resides. */
|
|
|
479
|
|
|
480 void
|
|
|
481 symtab_node::dissolve_same_comdat_group_list (void)
|
|
|
482 {
|
|
|
483 symtab_node *n = this;
|
|
|
484 symtab_node *next;
|
|
|
485
|
|
|
486 if (!same_comdat_group)
|
|
|
487 return;
|
|
|
488 do
|
|
|
489 {
|
|
|
490 next = n->same_comdat_group;
|
|
|
491 n->same_comdat_group = NULL;
|
|
145
|
492 if (dyn_cast <cgraph_node *> (n))
|
|
|
493 dyn_cast <cgraph_node *> (n)->calls_comdat_local = false;
|
|
111
|
494 /* Clear comdat_group for comdat locals, since
|
|
|
495 make_decl_local doesn't. */
|
|
|
496 if (!TREE_PUBLIC (n->decl))
|
|
|
497 n->set_comdat_group (NULL);
|
|
|
498 n = next;
|
|
|
499 }
|
|
|
500 while (n != this);
|
|
|
501 }
|
|
|
502
|
|
|
503 /* Return printable assembler name of NODE.
|
|
|
504 This function is used only for debugging. When assembler name
|
|
|
505 is unknown go with identifier name. */
|
|
|
506
|
|
|
507 const char *
|
|
|
508 symtab_node::asm_name () const
|
|
|
509 {
|
|
|
510 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
|
|
|
511 return name ();
|
|
|
512 return IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
|
|
|
513 }
|
|
|
514
|
|
|
515 /* Return printable identifier name. */
|
|
|
516
|
|
|
517 const char *
|
|
|
518 symtab_node::name () const
|
|
|
519 {
|
|
|
520 if (!DECL_NAME (decl))
|
|
|
521 {
|
|
|
522 if (DECL_ASSEMBLER_NAME_SET_P (decl))
|
|
|
523 return asm_name ();
|
|
|
524 else
|
|
|
525 return "<unnamed>";
|
|
|
526 }
|
|
|
527 return lang_hooks.decl_printable_name (decl, 2);
|
|
|
528 }
|
|
|
529
|
|
|
530 const char *
|
|
|
531 symtab_node::get_dump_name (bool asm_name_p) const
|
|
|
532 {
|
|
|
533 #define EXTRA 16
|
|
|
534 const char *fname = asm_name_p ? asm_name () : name ();
|
|
|
535 unsigned l = strlen (fname);
|
|
|
536
|
|
|
537 char *s = (char *)ggc_internal_cleared_alloc (l + EXTRA);
|
|
|
538 snprintf (s, l + EXTRA, "%s/%d", fname, order);
|
|
|
539
|
|
|
540 return s;
|
|
|
541 }
|
|
|
542
|
|
|
543 const char *
|
|
|
544 symtab_node::dump_name () const
|
|
|
545 {
|
|
|
546 return get_dump_name (false);
|
|
|
547 }
|
|
|
548
|
|
|
549 const char *
|
|
|
550 symtab_node::dump_asm_name () const
|
|
|
551 {
|
|
|
552 return get_dump_name (true);
|
|
|
553 }
|
|
|
554
|
|
|
555 /* Return ipa reference from this symtab_node to
|
|
145
|
556 REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type
|
|
111
|
557 of the use. */
|
|
|
558
|
|
|
559 ipa_ref *
|
|
|
560 symtab_node::create_reference (symtab_node *referred_node,
|
|
|
561 enum ipa_ref_use use_type)
|
|
|
562 {
|
|
|
563 return create_reference (referred_node, use_type, NULL);
|
|
|
564 }
|
|
|
565
|
|
|
566
|
|
|
567 /* Return ipa reference from this symtab_node to
|
|
145
|
568 REFERRED_NODE or REFERRED_VARPOOL_NODE. USE_TYPE specify type
|
|
111
|
569 of the use and STMT the statement (if it exists). */
|
|
|
570
|
|
|
571 ipa_ref *
|
|
|
572 symtab_node::create_reference (symtab_node *referred_node,
|
|
|
573 enum ipa_ref_use use_type, gimple *stmt)
|
|
|
574 {
|
|
|
575 ipa_ref *ref = NULL, *ref2 = NULL;
|
|
|
576 ipa_ref_list *list, *list2;
|
|
|
577 ipa_ref_t *old_references;
|
|
|
578
|
|
|
579 gcc_checking_assert (!stmt || is_a <cgraph_node *> (this));
|
|
|
580 gcc_checking_assert (use_type != IPA_REF_ALIAS || !stmt);
|
|
|
581
|
|
|
582 list = &ref_list;
|
|
|
583 old_references = vec_safe_address (list->references);
|
|
|
584 vec_safe_grow (list->references, vec_safe_length (list->references) + 1);
|
|
|
585 ref = &list->references->last ();
|
|
|
586
|
|
|
587 list2 = &referred_node->ref_list;
|
|
|
588
|
|
|
589 /* IPA_REF_ALIAS is always inserted at the beginning of the list. */
|
|
|
590 if(use_type == IPA_REF_ALIAS)
|
|
|
591 {
|
|
|
592 list2->referring.safe_insert (0, ref);
|
|
|
593 ref->referred_index = 0;
|
|
|
594
|
|
|
595 for (unsigned int i = 1; i < list2->referring.length (); i++)
|
|
|
596 list2->referring[i]->referred_index = i;
|
|
|
597 }
|
|
|
598 else
|
|
|
599 {
|
|
|
600 list2->referring.safe_push (ref);
|
|
|
601 ref->referred_index = list2->referring.length () - 1;
|
|
|
602 }
|
|
|
603
|
|
|
604 ref->referring = this;
|
|
|
605 ref->referred = referred_node;
|
|
|
606 ref->stmt = stmt;
|
|
|
607 ref->lto_stmt_uid = 0;
|
|
145
|
608 ref->speculative_id = 0;
|
|
111
|
609 ref->use = use_type;
|
|
|
610 ref->speculative = 0;
|
|
|
611
|
|
|
612 /* If vector was moved in memory, update pointers. */
|
|
|
613 if (old_references != list->references->address ())
|
|
|
614 {
|
|
|
615 int i;
|
|
|
616 for (i = 0; iterate_reference(i, ref2); i++)
|
|
|
617 ref2->referred_ref_list ()->referring[ref2->referred_index] = ref2;
|
|
|
618 }
|
|
|
619 return ref;
|
|
|
620 }
|
|
|
621
|
|
|
622 ipa_ref *
|
|
|
623 symtab_node::maybe_create_reference (tree val, gimple *stmt)
|
|
|
624 {
|
|
|
625 STRIP_NOPS (val);
|
|
|
626 ipa_ref_use use_type;
|
|
|
627
|
|
|
628 switch (TREE_CODE (val))
|
|
|
629 {
|
|
|
630 case VAR_DECL:
|
|
|
631 use_type = IPA_REF_LOAD;
|
|
|
632 break;
|
|
|
633 case ADDR_EXPR:
|
|
|
634 use_type = IPA_REF_ADDR;
|
|
|
635 break;
|
|
|
636 default:
|
|
|
637 gcc_assert (!handled_component_p (val));
|
|
|
638 return NULL;
|
|
|
639 }
|
|
|
640
|
|
|
641 val = get_base_var (val);
|
|
|
642 if (val && VAR_OR_FUNCTION_DECL_P (val))
|
|
|
643 {
|
|
|
644 symtab_node *referred = symtab_node::get (val);
|
|
|
645 gcc_checking_assert (referred);
|
|
|
646 return create_reference (referred, use_type, stmt);
|
|
|
647 }
|
|
|
648 return NULL;
|
|
|
649 }
|
|
|
650
|
|
|
651 /* Clone all references from symtab NODE to this symtab_node. */
|
|
|
652
|
|
|
653 void
|
|
|
654 symtab_node::clone_references (symtab_node *node)
|
|
|
655 {
|
|
|
656 ipa_ref *ref = NULL, *ref2 = NULL;
|
|
|
657 int i;
|
|
|
658 for (i = 0; node->iterate_reference (i, ref); i++)
|
|
|
659 {
|
|
|
660 bool speculative = ref->speculative;
|
|
|
661 unsigned int stmt_uid = ref->lto_stmt_uid;
|
|
|
662
|
|
|
663 ref2 = create_reference (ref->referred, ref->use, ref->stmt);
|
|
|
664 ref2->speculative = speculative;
|
|
|
665 ref2->lto_stmt_uid = stmt_uid;
|
|
145
|
666 ref2->speculative_id = ref->speculative_id;
|
|
111
|
667 }
|
|
|
668 }
|
|
|
669
|
|
|
670 /* Clone all referring from symtab NODE to this symtab_node. */
|
|
|
671
|
|
|
672 void
|
|
|
673 symtab_node::clone_referring (symtab_node *node)
|
|
|
674 {
|
|
|
675 ipa_ref *ref = NULL, *ref2 = NULL;
|
|
|
676 int i;
|
|
|
677 for (i = 0; node->iterate_referring(i, ref); i++)
|
|
|
678 {
|
|
|
679 bool speculative = ref->speculative;
|
|
|
680 unsigned int stmt_uid = ref->lto_stmt_uid;
|
|
|
681
|
|
|
682 ref2 = ref->referring->create_reference (this, ref->use, ref->stmt);
|
|
|
683 ref2->speculative = speculative;
|
|
|
684 ref2->lto_stmt_uid = stmt_uid;
|
|
145
|
685 ref2->speculative_id = ref->speculative_id;
|
|
111
|
686 }
|
|
|
687 }
|
|
|
688
|
|
|
689 /* Clone reference REF to this symtab_node and set its stmt to STMT. */
|
|
|
690
|
|
|
691 ipa_ref *
|
|
|
692 symtab_node::clone_reference (ipa_ref *ref, gimple *stmt)
|
|
|
693 {
|
|
|
694 bool speculative = ref->speculative;
|
|
|
695 unsigned int stmt_uid = ref->lto_stmt_uid;
|
|
|
696 ipa_ref *ref2;
|
|
|
697
|
|
|
698 ref2 = create_reference (ref->referred, ref->use, stmt);
|
|
|
699 ref2->speculative = speculative;
|
|
|
700 ref2->lto_stmt_uid = stmt_uid;
|
|
145
|
701 ref2->speculative_id = ref->speculative_id;
|
|
111
|
702 return ref2;
|
|
|
703 }
|
|
|
704
|
|
|
705 /* Find the structure describing a reference to REFERRED_NODE
|
|
|
706 and associated with statement STMT. */
|
|
|
707
|
|
|
708 ipa_ref *
|
|
|
709 symtab_node::find_reference (symtab_node *referred_node,
|
|
|
710 gimple *stmt, unsigned int lto_stmt_uid)
|
|
|
711 {
|
|
|
712 ipa_ref *r = NULL;
|
|
|
713 int i;
|
|
|
714
|
|
|
715 for (i = 0; iterate_reference (i, r); i++)
|
|
|
716 if (r->referred == referred_node
|
|
|
717 && !r->speculative
|
|
|
718 && ((stmt && r->stmt == stmt)
|
|
|
719 || (lto_stmt_uid && r->lto_stmt_uid == lto_stmt_uid)
|
|
|
720 || (!stmt && !lto_stmt_uid && !r->stmt && !r->lto_stmt_uid)))
|
|
|
721 return r;
|
|
|
722 return NULL;
|
|
|
723 }
|
|
|
724
|
|
|
725 /* Remove all references that are associated with statement STMT. */
|
|
|
726
|
|
|
727 void
|
|
|
728 symtab_node::remove_stmt_references (gimple *stmt)
|
|
|
729 {
|
|
|
730 ipa_ref *r = NULL;
|
|
|
731 int i = 0;
|
|
|
732
|
|
|
733 while (iterate_reference (i, r))
|
|
|
734 if (r->stmt == stmt)
|
|
|
735 r->remove_reference ();
|
|
|
736 else
|
|
|
737 i++;
|
|
|
738 }
|
|
|
739
|
|
|
740 /* Remove all stmt references in non-speculative references.
|
|
145
|
741 Those are not maintained during inlining & cloning.
|
|
111
|
742 The exception are speculative references that are updated along
|
|
|
743 with callgraph edges associated with them. */
|
|
|
744
|
|
|
745 void
|
|
|
746 symtab_node::clear_stmts_in_references (void)
|
|
|
747 {
|
|
|
748 ipa_ref *r = NULL;
|
|
|
749 int i;
|
|
|
750
|
|
|
751 for (i = 0; iterate_reference (i, r); i++)
|
|
|
752 if (!r->speculative)
|
|
|
753 {
|
|
|
754 r->stmt = NULL;
|
|
|
755 r->lto_stmt_uid = 0;
|
|
145
|
756 r->speculative_id = 0;
|
|
111
|
757 }
|
|
|
758 }
|
|
|
759
|
|
|
760 /* Remove all references in ref list. */
|
|
|
761
|
|
|
762 void
|
|
|
763 symtab_node::remove_all_references (void)
|
|
|
764 {
|
|
|
765 while (vec_safe_length (ref_list.references))
|
|
|
766 ref_list.references->last ().remove_reference ();
|
|
|
767 vec_free (ref_list.references);
|
|
|
768 }
|
|
|
769
|
|
|
770 /* Remove all referring items in ref list. */
|
|
|
771
|
|
|
772 void
|
|
|
773 symtab_node::remove_all_referring (void)
|
|
|
774 {
|
|
|
775 while (ref_list.referring.length ())
|
|
|
776 ref_list.referring.last ()->remove_reference ();
|
|
|
777 ref_list.referring.release ();
|
|
|
778 }
|
|
|
779
|
|
|
780 /* Dump references in ref list to FILE. */
|
|
|
781
|
|
|
782 void
|
|
|
783 symtab_node::dump_references (FILE *file)
|
|
|
784 {
|
|
|
785 ipa_ref *ref = NULL;
|
|
|
786 int i;
|
|
|
787 for (i = 0; iterate_reference (i, ref); i++)
|
|
|
788 {
|
|
|
789 fprintf (file, "%s (%s)",
|
|
|
790 ref->referred->dump_asm_name (),
|
|
|
791 ipa_ref_use_name [ref->use]);
|
|
|
792 if (ref->speculative)
|
|
|
793 fprintf (file, " (speculative)");
|
|
|
794 }
|
|
|
795 fprintf (file, "\n");
|
|
|
796 }
|
|
|
797
|
|
|
798 /* Dump referring in list to FILE. */
|
|
|
799
|
|
|
800 void
|
|
|
801 symtab_node::dump_referring (FILE *file)
|
|
|
802 {
|
|
|
803 ipa_ref *ref = NULL;
|
|
|
804 int i;
|
|
|
805 for (i = 0; iterate_referring(i, ref); i++)
|
|
|
806 {
|
|
|
807 fprintf (file, "%s (%s)",
|
|
|
808 ref->referring->dump_asm_name (),
|
|
|
809 ipa_ref_use_name [ref->use]);
|
|
|
810 if (ref->speculative)
|
|
|
811 fprintf (file, " (speculative)");
|
|
|
812 }
|
|
|
813 fprintf (file, "\n");
|
|
|
814 }
|
|
|
815
|
|
|
816 static const char * const symtab_type_names[] = {"symbol", "function", "variable"};
|
|
|
817
|
|
145
|
818 /* Dump the visibility of the symbol. */
|
|
|
819
|
|
|
820 const char *
|
|
|
821 symtab_node::get_visibility_string () const
|
|
|
822 {
|
|
|
823 static const char * const visibility_types[]
|
|
|
824 = { "default", "protected", "hidden", "internal" };
|
|
|
825 return visibility_types[DECL_VISIBILITY (decl)];
|
|
|
826 }
|
|
|
827
|
|
|
828 /* Dump the type_name of the symbol. */
|
|
|
829 const char *
|
|
|
830 symtab_node::get_symtab_type_string () const
|
|
|
831 {
|
|
|
832 return symtab_type_names[type];
|
|
|
833 }
|
|
|
834
|
|
111
|
835 /* Dump base fields of symtab nodes to F. Not to be used directly. */
|
|
|
836
|
|
|
837 void
|
|
|
838 symtab_node::dump_base (FILE *f)
|
|
|
839 {
|
|
|
840 static const char * const visibility_types[] = {
|
|
|
841 "default", "protected", "hidden", "internal"
|
|
|
842 };
|
|
|
843
|
|
|
844 fprintf (f, "%s (%s)", dump_asm_name (), name ());
|
|
|
845 dump_addr (f, " @", (void *)this);
|
|
|
846 fprintf (f, "\n Type: %s", symtab_type_names[type]);
|
|
|
847
|
|
|
848 if (definition)
|
|
|
849 fprintf (f, " definition");
|
|
|
850 if (analyzed)
|
|
|
851 fprintf (f, " analyzed");
|
|
|
852 if (alias)
|
|
|
853 fprintf (f, " alias");
|
|
|
854 if (transparent_alias)
|
|
|
855 fprintf (f, " transparent_alias");
|
|
|
856 if (weakref)
|
|
|
857 fprintf (f, " weakref");
|
|
145
|
858 if (symver)
|
|
|
859 fprintf (f, " symver");
|
|
111
|
860 if (cpp_implicit_alias)
|
|
|
861 fprintf (f, " cpp_implicit_alias");
|
|
|
862 if (alias_target)
|
|
|
863 fprintf (f, " target:%s",
|
|
|
864 DECL_P (alias_target)
|
|
|
865 ? IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME
|
|
|
866 (alias_target))
|
|
|
867 : IDENTIFIER_POINTER (alias_target));
|
|
|
868 if (body_removed)
|
|
|
869 fprintf (f, "\n Body removed by symtab_remove_unreachable_nodes");
|
|
|
870 fprintf (f, "\n Visibility:");
|
|
|
871 if (in_other_partition)
|
|
|
872 fprintf (f, " in_other_partition");
|
|
|
873 if (used_from_other_partition)
|
|
|
874 fprintf (f, " used_from_other_partition");
|
|
|
875 if (force_output)
|
|
|
876 fprintf (f, " force_output");
|
|
|
877 if (forced_by_abi)
|
|
|
878 fprintf (f, " forced_by_abi");
|
|
|
879 if (externally_visible)
|
|
|
880 fprintf (f, " externally_visible");
|
|
|
881 if (no_reorder)
|
|
|
882 fprintf (f, " no_reorder");
|
|
|
883 if (resolution != LDPR_UNKNOWN)
|
|
|
884 fprintf (f, " %s",
|
|
|
885 ld_plugin_symbol_resolution_names[(int)resolution]);
|
|
|
886 if (TREE_ASM_WRITTEN (decl))
|
|
|
887 fprintf (f, " asm_written");
|
|
|
888 if (DECL_EXTERNAL (decl))
|
|
|
889 fprintf (f, " external");
|
|
|
890 if (TREE_PUBLIC (decl))
|
|
|
891 fprintf (f, " public");
|
|
|
892 if (DECL_COMMON (decl))
|
|
|
893 fprintf (f, " common");
|
|
|
894 if (DECL_WEAK (decl))
|
|
|
895 fprintf (f, " weak");
|
|
|
896 if (DECL_DLLIMPORT_P (decl))
|
|
|
897 fprintf (f, " dll_import");
|
|
|
898 if (DECL_COMDAT (decl))
|
|
|
899 fprintf (f, " comdat");
|
|
|
900 if (get_comdat_group ())
|
|
|
901 fprintf (f, " comdat_group:%s",
|
|
|
902 IDENTIFIER_POINTER (get_comdat_group_id ()));
|
|
|
903 if (DECL_ONE_ONLY (decl))
|
|
|
904 fprintf (f, " one_only");
|
|
|
905 if (get_section ())
|
|
|
906 fprintf (f, " section:%s",
|
|
|
907 get_section ());
|
|
|
908 if (implicit_section)
|
|
|
909 fprintf (f," (implicit_section)");
|
|
|
910 if (DECL_VISIBILITY_SPECIFIED (decl))
|
|
|
911 fprintf (f, " visibility_specified");
|
|
|
912 if (DECL_VISIBILITY (decl))
|
|
|
913 fprintf (f, " visibility:%s",
|
|
|
914 visibility_types [DECL_VISIBILITY (decl)]);
|
|
|
915 if (DECL_VIRTUAL_P (decl))
|
|
|
916 fprintf (f, " virtual");
|
|
|
917 if (DECL_ARTIFICIAL (decl))
|
|
|
918 fprintf (f, " artificial");
|
|
|
919 if (TREE_CODE (decl) == FUNCTION_DECL)
|
|
|
920 {
|
|
|
921 if (DECL_STATIC_CONSTRUCTOR (decl))
|
|
|
922 fprintf (f, " constructor");
|
|
|
923 if (DECL_STATIC_DESTRUCTOR (decl))
|
|
|
924 fprintf (f, " destructor");
|
|
|
925 }
|
|
145
|
926 if (ifunc_resolver)
|
|
|
927 fprintf (f, " ifunc_resolver");
|
|
111
|
928 fprintf (f, "\n");
|
|
145
|
929
|
|
111
|
930 if (same_comdat_group)
|
|
|
931 fprintf (f, " Same comdat group as: %s\n",
|
|
|
932 same_comdat_group->dump_asm_name ());
|
|
|
933 if (next_sharing_asm_name)
|
|
|
934 fprintf (f, " next sharing asm name: %i\n",
|
|
|
935 next_sharing_asm_name->order);
|
|
|
936 if (previous_sharing_asm_name)
|
|
|
937 fprintf (f, " previous sharing asm name: %i\n",
|
|
|
938 previous_sharing_asm_name->order);
|
|
|
939
|
|
|
940 if (address_taken)
|
|
|
941 fprintf (f, " Address is taken.\n");
|
|
|
942 if (aux)
|
|
|
943 {
|
|
|
944 fprintf (f, " Aux:");
|
|
|
945 dump_addr (f, " @", (void *)aux);
|
|
|
946 fprintf (f, "\n");
|
|
|
947 }
|
|
|
948
|
|
|
949 fprintf (f, " References: ");
|
|
|
950 dump_references (f);
|
|
|
951 fprintf (f, " Referring: ");
|
|
|
952 dump_referring (f);
|
|
|
953 if (lto_file_data)
|
|
|
954 fprintf (f, " Read from file: %s\n",
|
|
|
955 lto_file_data->file_name);
|
|
|
956 }
|
|
|
957
|
|
|
958 /* Dump symtab node to F. */
|
|
|
959
|
|
|
960 void
|
|
|
961 symtab_node::dump (FILE *f)
|
|
|
962 {
|
|
|
963 if (cgraph_node *cnode = dyn_cast <cgraph_node *> (this))
|
|
|
964 cnode->dump (f);
|
|
|
965 else if (varpool_node *vnode = dyn_cast <varpool_node *> (this))
|
|
|
966 vnode->dump (f);
|
|
|
967 }
|
|
|
968
|
|
|
969 void
|
|
145
|
970 symtab_node::dump_graphviz (FILE *f)
|
|
|
971 {
|
|
|
972 if (cgraph_node *cnode = dyn_cast <cgraph_node *> (this))
|
|
|
973 cnode->dump_graphviz (f);
|
|
|
974 }
|
|
|
975
|
|
|
976 void
|
|
111
|
977 symbol_table::dump (FILE *f)
|
|
|
978 {
|
|
|
979 symtab_node *node;
|
|
|
980 fprintf (f, "Symbol table:\n\n");
|
|
|
981 FOR_EACH_SYMBOL (node)
|
|
|
982 node->dump (f);
|
|
|
983 }
|
|
|
984
|
|
145
|
985 void
|
|
|
986 symbol_table::dump_graphviz (FILE *f)
|
|
|
987 {
|
|
|
988 symtab_node *node;
|
|
|
989 fprintf (f, "digraph symtab {\n");
|
|
|
990 FOR_EACH_SYMBOL (node)
|
|
|
991 node->dump_graphviz (f);
|
|
|
992 fprintf (f, "}\n");
|
|
|
993 }
|
|
|
994
|
|
131
|
995 DEBUG_FUNCTION void
|
|
|
996 symbol_table::debug (void)
|
|
|
997 {
|
|
|
998 dump (stderr);
|
|
|
999 }
|
|
|
1000
|
|
111
|
1001 /* Return the cgraph node that has ASMNAME for its DECL_ASSEMBLER_NAME.
|
|
|
1002 Return NULL if there's no such node. */
|
|
|
1003
|
|
|
1004 symtab_node *
|
|
|
1005 symtab_node::get_for_asmname (const_tree asmname)
|
|
|
1006 {
|
|
|
1007 symtab_node *node;
|
|
|
1008
|
|
|
1009 symtab->symtab_initialize_asm_name_hash ();
|
|
|
1010 hashval_t hash = symtab->decl_assembler_name_hash (asmname);
|
|
|
1011 symtab_node **slot
|
|
|
1012 = symtab->assembler_name_hash->find_slot_with_hash (asmname, hash,
|
|
|
1013 NO_INSERT);
|
|
|
1014
|
|
|
1015 if (slot)
|
|
|
1016 {
|
|
|
1017 node = *slot;
|
|
|
1018 return node;
|
|
|
1019 }
|
|
|
1020 return NULL;
|
|
|
1021 }
|
|
|
1022
|
|
|
1023 /* Dump symtab node NODE to stderr. */
|
|
|
1024
|
|
|
1025 DEBUG_FUNCTION void
|
|
|
1026 symtab_node::debug (void)
|
|
|
1027 {
|
|
|
1028 dump (stderr);
|
|
|
1029 }
|
|
|
1030
|
|
|
1031 /* Verify common part of symtab nodes. */
|
|
|
1032
|
|
145
|
1033 #if __GNUC__ >= 10
|
|
|
1034 /* Disable warnings about missing quoting in GCC diagnostics for
|
|
|
1035 the verification errors. Their format strings don't follow GCC
|
|
|
1036 diagnostic conventions and the calls are ultimately followed by
|
|
|
1037 one to internal_error. */
|
|
|
1038 # pragma GCC diagnostic push
|
|
|
1039 # pragma GCC diagnostic ignored "-Wformat-diag"
|
|
|
1040 #endif
|
|
|
1041
|
|
111
|
1042 DEBUG_FUNCTION bool
|
|
|
1043 symtab_node::verify_base (void)
|
|
|
1044 {
|
|
|
1045 bool error_found = false;
|
|
|
1046 symtab_node *hashed_node;
|
|
|
1047
|
|
|
1048 if (is_a <cgraph_node *> (this))
|
|
|
1049 {
|
|
|
1050 if (TREE_CODE (decl) != FUNCTION_DECL)
|
|
|
1051 {
|
|
|
1052 error ("function symbol is not function");
|
|
|
1053 error_found = true;
|
|
|
1054 }
|
|
131
|
1055 else if ((lookup_attribute ("ifunc", DECL_ATTRIBUTES (decl))
|
|
|
1056 != NULL)
|
|
|
1057 != dyn_cast <cgraph_node *> (this)->ifunc_resolver)
|
|
|
1058 {
|
|
145
|
1059 error ("inconsistent %<ifunc%> attribute");
|
|
131
|
1060 error_found = true;
|
|
|
1061 }
|
|
111
|
1062 }
|
|
|
1063 else if (is_a <varpool_node *> (this))
|
|
|
1064 {
|
|
|
1065 if (!VAR_P (decl))
|
|
|
1066 {
|
|
|
1067 error ("variable symbol is not variable");
|
|
|
1068 error_found = true;
|
|
|
1069 }
|
|
|
1070 }
|
|
|
1071 else
|
|
|
1072 {
|
|
|
1073 error ("node has unknown type");
|
|
|
1074 error_found = true;
|
|
|
1075 }
|
|
|
1076
|
|
|
1077 if (symtab->state != LTO_STREAMING)
|
|
|
1078 {
|
|
|
1079 hashed_node = symtab_node::get (decl);
|
|
|
1080 if (!hashed_node)
|
|
|
1081 {
|
|
|
1082 error ("node not found node->decl->decl_with_vis.symtab_node");
|
|
|
1083 error_found = true;
|
|
|
1084 }
|
|
|
1085 if (hashed_node != this
|
|
|
1086 && (!is_a <cgraph_node *> (this)
|
|
|
1087 || !dyn_cast <cgraph_node *> (this)->clone_of
|
|
|
1088 || dyn_cast <cgraph_node *> (this)->clone_of->decl != decl))
|
|
|
1089 {
|
|
|
1090 error ("node differs from node->decl->decl_with_vis.symtab_node");
|
|
|
1091 error_found = true;
|
|
|
1092 }
|
|
|
1093 }
|
|
|
1094 if (symtab->assembler_name_hash)
|
|
|
1095 {
|
|
|
1096 hashed_node = symtab_node::get_for_asmname (DECL_ASSEMBLER_NAME (decl));
|
|
145
|
1097 if (hashed_node)
|
|
111
|
1098 {
|
|
145
|
1099 if (hashed_node->previous_sharing_asm_name)
|
|
|
1100 {
|
|
|
1101 error ("assembler name hash list corrupted");
|
|
|
1102 error_found = true;
|
|
|
1103 }
|
|
|
1104 else if (previous_sharing_asm_name == NULL)
|
|
|
1105 {
|
|
|
1106 if (hashed_node != this)
|
|
|
1107 {
|
|
|
1108 error ("assembler name hash list corrupted");
|
|
|
1109 error_found = true;
|
|
|
1110 }
|
|
|
1111 }
|
|
|
1112 else if (!(is_a <varpool_node *> (this) && DECL_HARD_REGISTER (decl)))
|
|
|
1113 {
|
|
|
1114 if (!asmname_hasher::equal (previous_sharing_asm_name,
|
|
|
1115 DECL_ASSEMBLER_NAME (decl)))
|
|
|
1116 {
|
|
|
1117 error ("node not found in symtab assembler name hash");
|
|
|
1118 error_found = true;
|
|
|
1119 }
|
|
|
1120 }
|
|
111
|
1121 }
|
|
|
1122 }
|
|
|
1123 if (previous_sharing_asm_name
|
|
|
1124 && previous_sharing_asm_name->next_sharing_asm_name != this)
|
|
|
1125 {
|
|
|
1126 error ("double linked list of assembler names corrupted");
|
|
|
1127 error_found = true;
|
|
|
1128 }
|
|
|
1129 if (body_removed && definition)
|
|
|
1130 {
|
|
|
1131 error ("node has body_removed but is definition");
|
|
|
1132 error_found = true;
|
|
|
1133 }
|
|
|
1134 if (analyzed && !definition)
|
|
|
1135 {
|
|
|
1136 error ("node is analyzed but it is not a definition");
|
|
|
1137 error_found = true;
|
|
|
1138 }
|
|
|
1139 if (cpp_implicit_alias && !alias)
|
|
|
1140 {
|
|
|
1141 error ("node is alias but not implicit alias");
|
|
|
1142 error_found = true;
|
|
|
1143 }
|
|
|
1144 if (alias && !definition && !weakref)
|
|
|
1145 {
|
|
|
1146 error ("node is alias but not definition");
|
|
|
1147 error_found = true;
|
|
|
1148 }
|
|
|
1149 if (weakref && !transparent_alias)
|
|
|
1150 {
|
|
|
1151 error ("node is weakref but not an transparent_alias");
|
|
|
1152 error_found = true;
|
|
|
1153 }
|
|
|
1154 if (transparent_alias && !alias)
|
|
|
1155 {
|
|
|
1156 error ("node is transparent_alias but not an alias");
|
|
|
1157 error_found = true;
|
|
|
1158 }
|
|
145
|
1159 if (symver && !alias)
|
|
|
1160 {
|
|
|
1161 error ("node is symver but not alias");
|
|
|
1162 error_found = true;
|
|
|
1163 }
|
|
|
1164 /* Limitation of gas requires us to output targets of symver aliases as
|
|
|
1165 global symbols. This is binutils PR 25295. */
|
|
|
1166 if (symver
|
|
|
1167 && (!TREE_PUBLIC (get_alias_target ()->decl)
|
|
|
1168 || DECL_VISIBILITY (get_alias_target ()->decl) != VISIBILITY_DEFAULT))
|
|
|
1169 {
|
|
|
1170 error ("symver target is not exported with default visibility");
|
|
|
1171 error_found = true;
|
|
|
1172 }
|
|
|
1173 if (symver
|
|
|
1174 && (!TREE_PUBLIC (decl)
|
|
|
1175 || DECL_VISIBILITY (decl) != VISIBILITY_DEFAULT))
|
|
|
1176 {
|
|
|
1177 error ("symver is not exported with default visibility");
|
|
|
1178 error_found = true;
|
|
|
1179 }
|
|
111
|
1180 if (same_comdat_group)
|
|
|
1181 {
|
|
|
1182 symtab_node *n = same_comdat_group;
|
|
|
1183
|
|
|
1184 if (!n->get_comdat_group ())
|
|
|
1185 {
|
|
|
1186 error ("node is in same_comdat_group list but has no comdat_group");
|
|
|
1187 error_found = true;
|
|
|
1188 }
|
|
|
1189 if (n->get_comdat_group () != get_comdat_group ())
|
|
|
1190 {
|
|
|
1191 error ("same_comdat_group list across different groups");
|
|
|
1192 error_found = true;
|
|
|
1193 }
|
|
|
1194 if (n->type != type)
|
|
|
1195 {
|
|
|
1196 error ("mixing different types of symbol in same comdat groups is not supported");
|
|
|
1197 error_found = true;
|
|
|
1198 }
|
|
|
1199 if (n == this)
|
|
|
1200 {
|
|
|
1201 error ("node is alone in a comdat group");
|
|
|
1202 error_found = true;
|
|
|
1203 }
|
|
|
1204 do
|
|
|
1205 {
|
|
|
1206 if (!n->same_comdat_group)
|
|
|
1207 {
|
|
|
1208 error ("same_comdat_group is not a circular list");
|
|
|
1209 error_found = true;
|
|
|
1210 break;
|
|
|
1211 }
|
|
|
1212 n = n->same_comdat_group;
|
|
|
1213 }
|
|
|
1214 while (n != this);
|
|
|
1215 if (comdat_local_p ())
|
|
|
1216 {
|
|
|
1217 ipa_ref *ref = NULL;
|
|
|
1218
|
|
|
1219 for (int i = 0; iterate_referring (i, ref); ++i)
|
|
|
1220 {
|
|
|
1221 if (!in_same_comdat_group_p (ref->referring))
|
|
|
1222 {
|
|
|
1223 error ("comdat-local symbol referred to by %s outside its "
|
|
|
1224 "comdat",
|
|
|
1225 identifier_to_locale (ref->referring->name()));
|
|
|
1226 error_found = true;
|
|
|
1227 }
|
|
|
1228 }
|
|
|
1229 }
|
|
|
1230 }
|
|
|
1231 if (implicit_section && !get_section ())
|
|
|
1232 {
|
|
145
|
1233 error ("implicit_section flag is set but section isn%'t");
|
|
111
|
1234 error_found = true;
|
|
|
1235 }
|
|
|
1236 if (get_section () && get_comdat_group ()
|
|
|
1237 && !implicit_section
|
|
|
1238 && !lookup_attribute ("section", DECL_ATTRIBUTES (decl)))
|
|
|
1239 {
|
|
|
1240 error ("Both section and comdat group is set");
|
|
|
1241 error_found = true;
|
|
|
1242 }
|
|
|
1243 /* TODO: Add string table for sections, so we do not keep holding duplicated
|
|
|
1244 strings. */
|
|
|
1245 if (alias && definition
|
|
|
1246 && get_section () != get_alias_target ()->get_section ()
|
|
|
1247 && (!get_section()
|
|
|
1248 || !get_alias_target ()->get_section ()
|
|
|
1249 || strcmp (get_section(),
|
|
|
1250 get_alias_target ()->get_section ())))
|
|
|
1251 {
|
|
145
|
1252 error ("Alias and target%'s section differs");
|
|
111
|
1253 get_alias_target ()->dump (stderr);
|
|
|
1254 error_found = true;
|
|
|
1255 }
|
|
|
1256 if (alias && definition
|
|
|
1257 && get_comdat_group () != get_alias_target ()->get_comdat_group ())
|
|
|
1258 {
|
|
145
|
1259 error ("Alias and target%'s comdat groups differs");
|
|
111
|
1260 get_alias_target ()->dump (stderr);
|
|
|
1261 error_found = true;
|
|
|
1262 }
|
|
|
1263 if (transparent_alias && definition && !weakref)
|
|
|
1264 {
|
|
|
1265 symtab_node *to = get_alias_target ();
|
|
|
1266 const char *name1
|
|
|
1267 = IDENTIFIER_POINTER (
|
|
|
1268 ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (decl)));
|
|
|
1269 const char *name2
|
|
|
1270 = IDENTIFIER_POINTER (
|
|
|
1271 ultimate_transparent_alias_target (DECL_ASSEMBLER_NAME (to->decl)));
|
|
|
1272 if (!symbol_table::assembler_names_equal_p (name1, name2))
|
|
|
1273 {
|
|
145
|
1274 error ("Transparent alias and target%'s assembler names differs");
|
|
111
|
1275 get_alias_target ()->dump (stderr);
|
|
|
1276 error_found = true;
|
|
|
1277 }
|
|
|
1278 }
|
|
|
1279 if (transparent_alias && definition
|
|
|
1280 && get_alias_target()->transparent_alias && get_alias_target()->analyzed)
|
|
|
1281 {
|
|
|
1282 error ("Chained transparent aliases");
|
|
|
1283 get_alias_target ()->dump (stderr);
|
|
|
1284 error_found = true;
|
|
|
1285 }
|
|
|
1286
|
|
|
1287 return error_found;
|
|
|
1288 }
|
|
|
1289
|
|
|
1290 /* Verify consistency of NODE. */
|
|
|
1291
|
|
|
1292 DEBUG_FUNCTION void
|
|
|
1293 symtab_node::verify (void)
|
|
|
1294 {
|
|
|
1295 if (seen_error ())
|
|
|
1296 return;
|
|
|
1297
|
|
|
1298 timevar_push (TV_CGRAPH_VERIFY);
|
|
|
1299 if (cgraph_node *node = dyn_cast <cgraph_node *> (this))
|
|
|
1300 node->verify_node ();
|
|
|
1301 else
|
|
|
1302 if (verify_base ())
|
|
|
1303 {
|
|
|
1304 debug ();
|
|
|
1305 internal_error ("symtab_node::verify failed");
|
|
|
1306 }
|
|
|
1307 timevar_pop (TV_CGRAPH_VERIFY);
|
|
|
1308 }
|
|
|
1309
|
|
|
1310 /* Verify symbol table for internal consistency. */
|
|
|
1311
|
|
|
1312 DEBUG_FUNCTION void
|
|
|
1313 symtab_node::verify_symtab_nodes (void)
|
|
|
1314 {
|
|
|
1315 symtab_node *node;
|
|
|
1316 hash_map<tree, symtab_node *> comdat_head_map (251);
|
|
|
1317
|
|
|
1318 FOR_EACH_SYMBOL (node)
|
|
|
1319 {
|
|
|
1320 node->verify ();
|
|
|
1321 if (node->get_comdat_group ())
|
|
|
1322 {
|
|
|
1323 symtab_node **entry, *s;
|
|
|
1324 bool existed;
|
|
|
1325
|
|
|
1326 entry = &comdat_head_map.get_or_insert (node->get_comdat_group (),
|
|
|
1327 &existed);
|
|
|
1328 if (!existed)
|
|
|
1329 *entry = node;
|
|
|
1330 else if (!DECL_EXTERNAL (node->decl))
|
|
|
1331 {
|
|
|
1332 for (s = (*entry)->same_comdat_group;
|
|
|
1333 s != NULL && s != node && s != *entry;
|
|
|
1334 s = s->same_comdat_group)
|
|
|
1335 ;
|
|
|
1336 if (!s || s == *entry)
|
|
|
1337 {
|
|
|
1338 error ("Two symbols with same comdat_group are not linked by "
|
|
|
1339 "the same_comdat_group list.");
|
|
|
1340 (*entry)->debug ();
|
|
|
1341 node->debug ();
|
|
|
1342 internal_error ("symtab_node::verify failed");
|
|
|
1343 }
|
|
|
1344 }
|
|
|
1345 }
|
|
|
1346 }
|
|
|
1347 }
|
|
|
1348
|
|
145
|
1349 #if __GNUC__ >= 10
|
|
|
1350 # pragma GCC diagnostic pop
|
|
|
1351 #endif
|
|
|
1352
|
|
111
|
1353 /* Make DECL local. FIXME: We shouldn't need to mess with rtl this early,
|
|
|
1354 but other code such as notice_global_symbol generates rtl. */
|
|
|
1355
|
|
|
1356 void
|
|
|
1357 symtab_node::make_decl_local (void)
|
|
|
1358 {
|
|
|
1359 rtx rtl, symbol;
|
|
|
1360
|
|
|
1361 if (weakref)
|
|
|
1362 {
|
|
|
1363 weakref = false;
|
|
|
1364 IDENTIFIER_TRANSPARENT_ALIAS (DECL_ASSEMBLER_NAME (decl)) = 0;
|
|
|
1365 TREE_CHAIN (DECL_ASSEMBLER_NAME (decl)) = NULL_TREE;
|
|
|
1366 symtab->change_decl_assembler_name
|
|
|
1367 (decl, DECL_ASSEMBLER_NAME (get_alias_target ()->decl));
|
|
|
1368 DECL_ATTRIBUTES (decl) = remove_attribute ("weakref",
|
|
|
1369 DECL_ATTRIBUTES (decl));
|
|
|
1370 }
|
|
|
1371 /* Avoid clearing comdat_groups on comdat-local decls. */
|
|
|
1372 else if (TREE_PUBLIC (decl) == 0)
|
|
|
1373 return;
|
|
|
1374
|
|
|
1375 /* Localizing a symbol also make all its transparent aliases local. */
|
|
|
1376 ipa_ref *ref;
|
|
|
1377 for (unsigned i = 0; iterate_direct_aliases (i, ref); i++)
|
|
|
1378 {
|
|
|
1379 struct symtab_node *alias = ref->referring;
|
|
|
1380 if (alias->transparent_alias)
|
|
|
1381 alias->make_decl_local ();
|
|
|
1382 }
|
|
|
1383
|
|
|
1384 if (VAR_P (decl))
|
|
|
1385 {
|
|
|
1386 DECL_COMMON (decl) = 0;
|
|
|
1387 /* ADDRESSABLE flag is not defined for public symbols. */
|
|
|
1388 TREE_ADDRESSABLE (decl) = 1;
|
|
|
1389 TREE_STATIC (decl) = 1;
|
|
|
1390 }
|
|
|
1391 else
|
|
|
1392 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
|
|
|
1393
|
|
|
1394 DECL_COMDAT (decl) = 0;
|
|
|
1395 DECL_WEAK (decl) = 0;
|
|
|
1396 DECL_EXTERNAL (decl) = 0;
|
|
|
1397 DECL_VISIBILITY_SPECIFIED (decl) = 0;
|
|
|
1398 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
|
|
|
1399 TREE_PUBLIC (decl) = 0;
|
|
|
1400 DECL_DLLIMPORT_P (decl) = 0;
|
|
|
1401 if (!DECL_RTL_SET_P (decl))
|
|
|
1402 return;
|
|
|
1403
|
|
|
1404 /* Update rtl flags. */
|
|
|
1405 make_decl_rtl (decl);
|
|
|
1406
|
|
|
1407 rtl = DECL_RTL (decl);
|
|
|
1408 if (!MEM_P (rtl))
|
|
|
1409 return;
|
|
|
1410
|
|
|
1411 symbol = XEXP (rtl, 0);
|
|
|
1412 if (GET_CODE (symbol) != SYMBOL_REF)
|
|
|
1413 return;
|
|
|
1414
|
|
|
1415 SYMBOL_REF_WEAK (symbol) = DECL_WEAK (decl);
|
|
|
1416 }
|
|
|
1417
|
|
|
1418 /* Copy visibility from N.
|
|
|
1419 This is useful when THIS becomes a transparent alias of N. */
|
|
|
1420
|
|
|
1421 void
|
|
|
1422 symtab_node::copy_visibility_from (symtab_node *n)
|
|
|
1423 {
|
|
|
1424 gcc_checking_assert (n->weakref == weakref);
|
|
|
1425
|
|
|
1426 ipa_ref *ref;
|
|
|
1427 for (unsigned i = 0; iterate_direct_aliases (i, ref); i++)
|
|
|
1428 {
|
|
|
1429 struct symtab_node *alias = ref->referring;
|
|
|
1430 if (alias->transparent_alias)
|
|
|
1431 alias->copy_visibility_from (n);
|
|
|
1432 }
|
|
|
1433
|
|
|
1434 if (VAR_P (decl))
|
|
|
1435 {
|
|
|
1436 DECL_COMMON (decl) = DECL_COMMON (n->decl);
|
|
|
1437 /* ADDRESSABLE flag is not defined for public symbols. */
|
|
|
1438 if (TREE_PUBLIC (decl) && !TREE_PUBLIC (n->decl))
|
|
|
1439 TREE_ADDRESSABLE (decl) = 1;
|
|
|
1440 TREE_STATIC (decl) = TREE_STATIC (n->decl);
|
|
|
1441 }
|
|
|
1442 else gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
|
|
|
1443
|
|
|
1444 DECL_COMDAT (decl) = DECL_COMDAT (n->decl);
|
|
|
1445 DECL_WEAK (decl) = DECL_WEAK (n->decl);
|
|
|
1446 DECL_EXTERNAL (decl) = DECL_EXTERNAL (n->decl);
|
|
|
1447 DECL_VISIBILITY_SPECIFIED (decl) = DECL_VISIBILITY_SPECIFIED (n->decl);
|
|
|
1448 DECL_VISIBILITY (decl) = DECL_VISIBILITY (n->decl);
|
|
|
1449 TREE_PUBLIC (decl) = TREE_PUBLIC (n->decl);
|
|
|
1450 DECL_DLLIMPORT_P (decl) = DECL_DLLIMPORT_P (n->decl);
|
|
|
1451 resolution = n->resolution;
|
|
|
1452 set_comdat_group (n->get_comdat_group ());
|
|
|
1453 call_for_symbol_and_aliases (symtab_node::set_section,
|
|
|
1454 const_cast<char *>(n->get_section ()), true);
|
|
|
1455 externally_visible = n->externally_visible;
|
|
|
1456 if (!DECL_RTL_SET_P (decl))
|
|
|
1457 return;
|
|
|
1458
|
|
|
1459 /* Update rtl flags. */
|
|
|
1460 make_decl_rtl (decl);
|
|
|
1461
|
|
|
1462 rtx rtl = DECL_RTL (decl);
|
|
|
1463 if (!MEM_P (rtl))
|
|
|
1464 return;
|
|
|
1465
|
|
|
1466 rtx symbol = XEXP (rtl, 0);
|
|
|
1467 if (GET_CODE (symbol) != SYMBOL_REF)
|
|
|
1468 return;
|
|
|
1469
|
|
|
1470 SYMBOL_REF_WEAK (symbol) = DECL_WEAK (decl);
|
|
|
1471 }
|
|
|
1472
|
|
|
1473 /* Walk the alias chain to return the symbol NODE is alias of.
|
|
|
1474 If NODE is not an alias, return NODE.
|
|
|
1475 Assumes NODE is known to be alias. */
|
|
|
1476
|
|
|
1477 symtab_node *
|
|
|
1478 symtab_node::ultimate_alias_target_1 (enum availability *availability,
|
|
|
1479 symtab_node *ref)
|
|
|
1480 {
|
|
|
1481 bool transparent_p = false;
|
|
|
1482
|
|
|
1483 /* To determine visibility of the target, we follow ELF semantic of aliases.
|
|
|
1484 Here alias is an alternative assembler name of a given definition. Its
|
|
|
1485 availability prevails the availability of its target (i.e. static alias of
|
|
|
1486 weak definition is available.
|
|
|
1487
|
|
145
|
1488 Transparent alias is just alternative name of a given symbol used within
|
|
111
|
1489 one compilation unit and is translated prior hitting the object file. It
|
|
|
1490 inherits the visibility of its target.
|
|
|
1491 Weakref is a different animal (and noweak definition is weak).
|
|
|
1492
|
|
|
1493 If we ever get into supporting targets with different semantics, a target
|
|
|
1494 hook will be needed here. */
|
|
|
1495
|
|
|
1496 if (availability)
|
|
|
1497 {
|
|
|
1498 transparent_p = transparent_alias;
|
|
|
1499 if (!transparent_p)
|
|
|
1500 *availability = get_availability (ref);
|
|
|
1501 else
|
|
|
1502 *availability = AVAIL_NOT_AVAILABLE;
|
|
|
1503 }
|
|
|
1504
|
|
|
1505 symtab_node *node = this;
|
|
|
1506 while (node)
|
|
|
1507 {
|
|
|
1508 if (node->alias && node->analyzed)
|
|
|
1509 node = node->get_alias_target ();
|
|
|
1510 else
|
|
|
1511 {
|
|
|
1512 if (!availability || (!transparent_p && node->analyzed))
|
|
|
1513 ;
|
|
|
1514 else if (node->analyzed && !node->transparent_alias)
|
|
|
1515 *availability = node->get_availability (ref);
|
|
|
1516 else
|
|
|
1517 *availability = AVAIL_NOT_AVAILABLE;
|
|
|
1518 return node;
|
|
|
1519 }
|
|
|
1520 if (node && availability && transparent_p
|
|
|
1521 && node->transparent_alias)
|
|
|
1522 {
|
|
|
1523 *availability = node->get_availability (ref);
|
|
|
1524 transparent_p = false;
|
|
|
1525 }
|
|
|
1526 }
|
|
|
1527 if (availability)
|
|
|
1528 *availability = AVAIL_NOT_AVAILABLE;
|
|
|
1529 return NULL;
|
|
|
1530 }
|
|
|
1531
|
|
|
1532 /* C++ FE sometimes change linkage flags after producing same body aliases.
|
|
|
1533
|
|
|
1534 FIXME: C++ produce implicit aliases for virtual functions and vtables that
|
|
|
1535 are obviously equivalent. The way it is doing so is however somewhat
|
|
|
1536 kludgy and interferes with the visibility code. As a result we need to
|
|
|
1537 copy the visibility from the target to get things right. */
|
|
|
1538
|
|
|
1539 void
|
|
|
1540 symtab_node::fixup_same_cpp_alias_visibility (symtab_node *target)
|
|
|
1541 {
|
|
|
1542 if (is_a <cgraph_node *> (this))
|
|
|
1543 {
|
|
|
1544 DECL_DECLARED_INLINE_P (decl)
|
|
|
1545 = DECL_DECLARED_INLINE_P (target->decl);
|
|
|
1546 DECL_DISREGARD_INLINE_LIMITS (decl)
|
|
|
1547 = DECL_DISREGARD_INLINE_LIMITS (target->decl);
|
|
|
1548 }
|
|
|
1549 /* FIXME: It is not really clear why those flags should not be copied for
|
|
|
1550 functions, too. */
|
|
|
1551 else
|
|
|
1552 {
|
|
|
1553 DECL_WEAK (decl) = DECL_WEAK (target->decl);
|
|
|
1554 DECL_EXTERNAL (decl) = DECL_EXTERNAL (target->decl);
|
|
|
1555 DECL_VISIBILITY (decl) = DECL_VISIBILITY (target->decl);
|
|
|
1556 }
|
|
|
1557 if (TREE_PUBLIC (decl))
|
|
|
1558 {
|
|
|
1559 tree group;
|
|
|
1560
|
|
|
1561 DECL_EXTERNAL (decl) = DECL_EXTERNAL (target->decl);
|
|
|
1562 DECL_COMDAT (decl) = DECL_COMDAT (target->decl);
|
|
|
1563 group = target->get_comdat_group ();
|
|
|
1564 set_comdat_group (group);
|
|
|
1565 if (group && !same_comdat_group)
|
|
|
1566 add_to_same_comdat_group (target);
|
|
|
1567 }
|
|
|
1568 externally_visible = target->externally_visible;
|
|
|
1569 }
|
|
|
1570
|
|
|
1571 /* Set section, do not recurse into aliases.
|
|
|
1572 When one wants to change section of a symbol and its aliases,
|
|
|
1573 use set_section. */
|
|
|
1574
|
|
|
1575 void
|
|
|
1576 symtab_node::set_section_for_node (const char *section)
|
|
|
1577 {
|
|
|
1578 const char *current = get_section ();
|
|
|
1579 section_hash_entry **slot;
|
|
|
1580
|
|
|
1581 if (current == section
|
|
|
1582 || (current && section
|
|
|
1583 && !strcmp (current, section)))
|
|
|
1584 return;
|
|
|
1585
|
|
|
1586 if (current)
|
|
|
1587 {
|
|
|
1588 x_section->ref_count--;
|
|
|
1589 if (!x_section->ref_count)
|
|
|
1590 {
|
|
|
1591 hashval_t hash = htab_hash_string (x_section->name);
|
|
|
1592 slot = symtab->section_hash->find_slot_with_hash (x_section->name,
|
|
|
1593 hash, INSERT);
|
|
|
1594 ggc_free (x_section);
|
|
|
1595 symtab->section_hash->clear_slot (slot);
|
|
|
1596 }
|
|
|
1597 x_section = NULL;
|
|
|
1598 }
|
|
|
1599 if (!section)
|
|
|
1600 {
|
|
|
1601 implicit_section = false;
|
|
|
1602 return;
|
|
|
1603 }
|
|
|
1604 if (!symtab->section_hash)
|
|
|
1605 symtab->section_hash = hash_table<section_name_hasher>::create_ggc (10);
|
|
|
1606 slot = symtab->section_hash->find_slot_with_hash (section,
|
|
|
1607 htab_hash_string (section),
|
|
|
1608 INSERT);
|
|
|
1609 if (*slot)
|
|
|
1610 x_section = (section_hash_entry *)*slot;
|
|
|
1611 else
|
|
|
1612 {
|
|
|
1613 int len = strlen (section);
|
|
|
1614 *slot = x_section = ggc_cleared_alloc<section_hash_entry> ();
|
|
|
1615 x_section->name = ggc_vec_alloc<char> (len + 1);
|
|
|
1616 memcpy (x_section->name, section, len + 1);
|
|
|
1617 }
|
|
|
1618 x_section->ref_count++;
|
|
|
1619 }
|
|
|
1620
|
|
|
1621 /* Worker for set_section. */
|
|
|
1622
|
|
|
1623 bool
|
|
|
1624 symtab_node::set_section (symtab_node *n, void *s)
|
|
|
1625 {
|
|
|
1626 n->set_section_for_node ((char *)s);
|
|
|
1627 return false;
|
|
|
1628 }
|
|
|
1629
|
|
|
1630 /* Set section of symbol and its aliases. */
|
|
|
1631
|
|
|
1632 void
|
|
|
1633 symtab_node::set_section (const char *section)
|
|
|
1634 {
|
|
145
|
1635 gcc_assert (!this->alias || !this->analyzed);
|
|
111
|
1636 call_for_symbol_and_aliases
|
|
|
1637 (symtab_node::set_section, const_cast<char *>(section), true);
|
|
|
1638 }
|
|
|
1639
|
|
|
1640 /* Return the initialization priority. */
|
|
|
1641
|
|
|
1642 priority_type
|
|
|
1643 symtab_node::get_init_priority ()
|
|
|
1644 {
|
|
|
1645 if (!this->in_init_priority_hash)
|
|
|
1646 return DEFAULT_INIT_PRIORITY;
|
|
|
1647
|
|
|
1648 symbol_priority_map *h = symtab->init_priority_hash->get (this);
|
|
|
1649 return h ? h->init : DEFAULT_INIT_PRIORITY;
|
|
|
1650 }
|
|
|
1651
|
|
|
1652 /* Return the finalization priority. */
|
|
|
1653
|
|
|
1654 priority_type
|
|
|
1655 cgraph_node::get_fini_priority ()
|
|
|
1656 {
|
|
|
1657 if (!this->in_init_priority_hash)
|
|
|
1658 return DEFAULT_INIT_PRIORITY;
|
|
|
1659 symbol_priority_map *h = symtab->init_priority_hash->get (this);
|
|
|
1660 return h ? h->fini : DEFAULT_INIT_PRIORITY;
|
|
|
1661 }
|
|
|
1662
|
|
|
1663 /* Return the initialization and finalization priority information for
|
|
|
1664 DECL. If there is no previous priority information, a freshly
|
|
|
1665 allocated structure is returned. */
|
|
|
1666
|
|
|
1667 symbol_priority_map *
|
|
|
1668 symtab_node::priority_info (void)
|
|
|
1669 {
|
|
|
1670 if (!symtab->init_priority_hash)
|
|
|
1671 symtab->init_priority_hash = hash_map<symtab_node *, symbol_priority_map>::create_ggc (13);
|
|
|
1672
|
|
|
1673 bool existed;
|
|
|
1674 symbol_priority_map *h
|
|
|
1675 = &symtab->init_priority_hash->get_or_insert (this, &existed);
|
|
|
1676 if (!existed)
|
|
|
1677 {
|
|
|
1678 h->init = DEFAULT_INIT_PRIORITY;
|
|
|
1679 h->fini = DEFAULT_INIT_PRIORITY;
|
|
|
1680 in_init_priority_hash = true;
|
|
|
1681 }
|
|
|
1682
|
|
|
1683 return h;
|
|
|
1684 }
|
|
|
1685
|
|
|
1686 /* Set initialization priority to PRIORITY. */
|
|
|
1687
|
|
|
1688 void
|
|
|
1689 symtab_node::set_init_priority (priority_type priority)
|
|
|
1690 {
|
|
|
1691 symbol_priority_map *h;
|
|
|
1692
|
|
|
1693 if (is_a <cgraph_node *> (this))
|
|
|
1694 gcc_assert (DECL_STATIC_CONSTRUCTOR (this->decl));
|
|
|
1695
|
|
|
1696 if (priority == DEFAULT_INIT_PRIORITY)
|
|
|
1697 {
|
|
|
1698 gcc_assert (get_init_priority() == priority);
|
|
|
1699 return;
|
|
|
1700 }
|
|
|
1701 h = priority_info ();
|
|
|
1702 h->init = priority;
|
|
|
1703 }
|
|
|
1704
|
|
145
|
1705 /* Set finalization priority to PRIORITY. */
|
|
111
|
1706
|
|
|
1707 void
|
|
|
1708 cgraph_node::set_fini_priority (priority_type priority)
|
|
|
1709 {
|
|
|
1710 symbol_priority_map *h;
|
|
|
1711
|
|
|
1712 gcc_assert (DECL_STATIC_DESTRUCTOR (this->decl));
|
|
|
1713
|
|
|
1714 if (priority == DEFAULT_INIT_PRIORITY)
|
|
|
1715 {
|
|
|
1716 gcc_assert (get_fini_priority() == priority);
|
|
|
1717 return;
|
|
|
1718 }
|
|
|
1719 h = priority_info ();
|
|
|
1720 h->fini = priority;
|
|
|
1721 }
|
|
|
1722
|
|
|
1723 /* Worker for symtab_resolve_alias. */
|
|
|
1724
|
|
|
1725 bool
|
|
|
1726 symtab_node::set_implicit_section (symtab_node *n,
|
|
|
1727 void *data ATTRIBUTE_UNUSED)
|
|
|
1728 {
|
|
|
1729 n->implicit_section = true;
|
|
|
1730 return false;
|
|
|
1731 }
|
|
|
1732
|
|
|
1733 /* Add reference recording that symtab node is alias of TARGET.
|
|
|
1734 The function can fail in the case of aliasing cycles; in this case
|
|
|
1735 it returns false. */
|
|
|
1736
|
|
|
1737 bool
|
|
|
1738 symtab_node::resolve_alias (symtab_node *target, bool transparent)
|
|
|
1739 {
|
|
|
1740 symtab_node *n;
|
|
|
1741
|
|
|
1742 gcc_assert (!analyzed && !vec_safe_length (ref_list.references));
|
|
|
1743
|
|
|
1744 /* Never let cycles to creep into the symbol table alias references;
|
|
|
1745 those will make alias walkers to be infinite. */
|
|
|
1746 for (n = target; n && n->alias;
|
|
|
1747 n = n->analyzed ? n->get_alias_target () : NULL)
|
|
|
1748 if (n == this)
|
|
|
1749 {
|
|
|
1750 if (is_a <cgraph_node *> (this))
|
|
|
1751 error ("function %q+D part of alias cycle", decl);
|
|
|
1752 else if (is_a <varpool_node *> (this))
|
|
|
1753 error ("variable %q+D part of alias cycle", decl);
|
|
|
1754 else
|
|
|
1755 gcc_unreachable ();
|
|
|
1756 alias = false;
|
|
|
1757 return false;
|
|
|
1758 }
|
|
|
1759
|
|
|
1760 /* "analyze" the node - i.e. mark the reference. */
|
|
|
1761 definition = true;
|
|
|
1762 alias = true;
|
|
|
1763 analyzed = true;
|
|
|
1764 transparent |= transparent_alias;
|
|
|
1765 transparent_alias = transparent;
|
|
|
1766 if (transparent)
|
|
|
1767 while (target->transparent_alias && target->analyzed)
|
|
|
1768 target = target->get_alias_target ();
|
|
|
1769 create_reference (target, IPA_REF_ALIAS, NULL);
|
|
|
1770
|
|
|
1771 /* Add alias into the comdat group of its target unless it is already there. */
|
|
|
1772 if (same_comdat_group)
|
|
|
1773 remove_from_same_comdat_group ();
|
|
|
1774 set_comdat_group (NULL);
|
|
|
1775 if (target->get_comdat_group ())
|
|
|
1776 add_to_same_comdat_group (target);
|
|
|
1777
|
|
|
1778 if ((get_section () != target->get_section ()
|
|
|
1779 || target->get_comdat_group ()) && get_section () && !implicit_section)
|
|
|
1780 {
|
|
|
1781 error ("section of alias %q+D must match section of its target", decl);
|
|
|
1782 }
|
|
|
1783 call_for_symbol_and_aliases (symtab_node::set_section,
|
|
|
1784 const_cast<char *>(target->get_section ()), true);
|
|
|
1785 if (target->implicit_section)
|
|
|
1786 call_for_symbol_and_aliases (set_implicit_section, NULL, true);
|
|
|
1787
|
|
|
1788 /* Alias targets become redundant after alias is resolved into an reference.
|
|
|
1789 We do not want to keep it around or we would have to mind updating them
|
|
|
1790 when renaming symbols. */
|
|
|
1791 alias_target = NULL;
|
|
|
1792
|
|
|
1793 if (!transparent && cpp_implicit_alias && symtab->state >= CONSTRUCTION)
|
|
|
1794 fixup_same_cpp_alias_visibility (target);
|
|
|
1795
|
|
|
1796 /* If alias has address taken, so does the target. */
|
|
|
1797 if (address_taken)
|
|
|
1798 target->ultimate_alias_target ()->address_taken = true;
|
|
|
1799
|
|
|
1800 /* All non-transparent aliases of THIS are now in fact aliases of TARGET.
|
|
|
1801 If alias is transparent, also all transparent aliases of THIS are now
|
|
|
1802 aliases of TARGET.
|
|
|
1803 Also merge same comdat group lists. */
|
|
|
1804 ipa_ref *ref;
|
|
|
1805 for (unsigned i = 0; iterate_direct_aliases (i, ref);)
|
|
|
1806 {
|
|
|
1807 struct symtab_node *alias_alias = ref->referring;
|
|
|
1808 if (alias_alias->get_comdat_group ())
|
|
|
1809 {
|
|
|
1810 alias_alias->remove_from_same_comdat_group ();
|
|
|
1811 alias_alias->set_comdat_group (NULL);
|
|
|
1812 if (target->get_comdat_group ())
|
|
|
1813 alias_alias->add_to_same_comdat_group (target);
|
|
|
1814 }
|
|
145
|
1815 if ((!alias_alias->transparent_alias
|
|
|
1816 && !alias_alias->symver)
|
|
|
1817 || transparent)
|
|
111
|
1818 {
|
|
|
1819 alias_alias->remove_all_references ();
|
|
|
1820 alias_alias->create_reference (target, IPA_REF_ALIAS, NULL);
|
|
|
1821 }
|
|
|
1822 else i++;
|
|
|
1823 }
|
|
|
1824 return true;
|
|
|
1825 }
|
|
|
1826
|
|
|
1827 /* Worker searching noninterposable alias. */
|
|
|
1828
|
|
|
1829 bool
|
|
|
1830 symtab_node::noninterposable_alias (symtab_node *node, void *data)
|
|
|
1831 {
|
|
|
1832 if (!node->transparent_alias && decl_binds_to_current_def_p (node->decl))
|
|
|
1833 {
|
|
|
1834 symtab_node *fn = node->ultimate_alias_target ();
|
|
|
1835
|
|
|
1836 /* Ensure that the alias is well formed this may not be the case
|
|
|
1837 of user defined aliases and currently it is not always the case
|
|
|
1838 of C++ same body aliases (that is a bug). */
|
|
|
1839 if (TREE_TYPE (node->decl) != TREE_TYPE (fn->decl)
|
|
|
1840 || DECL_CONTEXT (node->decl) != DECL_CONTEXT (fn->decl)
|
|
|
1841 || (TREE_CODE (node->decl) == FUNCTION_DECL
|
|
|
1842 && flags_from_decl_or_type (node->decl)
|
|
|
1843 != flags_from_decl_or_type (fn->decl))
|
|
|
1844 || DECL_ATTRIBUTES (node->decl) != DECL_ATTRIBUTES (fn->decl))
|
|
|
1845 return false;
|
|
|
1846 *(symtab_node **)data = node;
|
|
|
1847 return true;
|
|
|
1848 }
|
|
|
1849 return false;
|
|
|
1850 }
|
|
|
1851
|
|
145
|
1852 /* If node cannot be overwriten by static or dynamic linker to point to
|
|
111
|
1853 different definition, return NODE. Otherwise look for alias with such
|
|
|
1854 property and if none exists, introduce new one. */
|
|
|
1855
|
|
|
1856 symtab_node *
|
|
|
1857 symtab_node::noninterposable_alias (void)
|
|
|
1858 {
|
|
|
1859 tree new_decl;
|
|
|
1860 symtab_node *new_node = NULL;
|
|
|
1861
|
|
|
1862 /* First try to look up existing alias or base object
|
|
|
1863 (if that is already non-overwritable). */
|
|
|
1864 symtab_node *node = ultimate_alias_target ();
|
|
|
1865 gcc_assert (!node->alias && !node->weakref);
|
|
|
1866 node->call_for_symbol_and_aliases (symtab_node::noninterposable_alias,
|
|
145
|
1867 (void *)&new_node, true);
|
|
111
|
1868 if (new_node)
|
|
|
1869 return new_node;
|
|
|
1870
|
|
|
1871 /* If aliases aren't supported by the assembler, fail. */
|
|
|
1872 if (!TARGET_SUPPORTS_ALIASES)
|
|
|
1873 return NULL;
|
|
|
1874
|
|
|
1875 /* Otherwise create a new one. */
|
|
|
1876 new_decl = copy_node (node->decl);
|
|
|
1877 DECL_DLLIMPORT_P (new_decl) = 0;
|
|
145
|
1878 tree name = clone_function_name (node->decl, "localalias");
|
|
|
1879 if (!flag_wpa)
|
|
|
1880 {
|
|
|
1881 unsigned long num = 0;
|
|
|
1882 /* In the rare case we already have a localalias, but the above
|
|
|
1883 node->call_for_symbol_and_aliases call didn't find any suitable,
|
|
|
1884 iterate until we find one not used yet. */
|
|
|
1885 while (symtab_node::get_for_asmname (name))
|
|
|
1886 name = clone_function_name (node->decl, "localalias", num++);
|
|
|
1887 }
|
|
|
1888 DECL_NAME (new_decl) = name;
|
|
111
|
1889 if (TREE_CODE (new_decl) == FUNCTION_DECL)
|
|
|
1890 DECL_STRUCT_FUNCTION (new_decl) = NULL;
|
|
|
1891 DECL_INITIAL (new_decl) = NULL;
|
|
|
1892 SET_DECL_ASSEMBLER_NAME (new_decl, DECL_NAME (new_decl));
|
|
|
1893 SET_DECL_RTL (new_decl, NULL);
|
|
|
1894
|
|
|
1895 /* Update the properties. */
|
|
|
1896 DECL_EXTERNAL (new_decl) = 0;
|
|
|
1897 TREE_PUBLIC (new_decl) = 0;
|
|
|
1898 DECL_COMDAT (new_decl) = 0;
|
|
|
1899 DECL_WEAK (new_decl) = 0;
|
|
|
1900
|
|
|
1901 /* Since the aliases can be added to vtables, keep DECL_VIRTUAL flag. */
|
|
|
1902 DECL_VIRTUAL_P (new_decl) = DECL_VIRTUAL_P (node->decl);
|
|
|
1903 if (TREE_CODE (new_decl) == FUNCTION_DECL)
|
|
|
1904 {
|
|
|
1905 DECL_STATIC_CONSTRUCTOR (new_decl) = 0;
|
|
|
1906 DECL_STATIC_DESTRUCTOR (new_decl) = 0;
|
|
|
1907 new_node = cgraph_node::create_alias (new_decl, node->decl);
|
|
145
|
1908
|
|
|
1909 cgraph_node *new_cnode = dyn_cast <cgraph_node *> (new_node),
|
|
|
1910 *cnode = dyn_cast <cgraph_node *> (node);
|
|
|
1911
|
|
|
1912 new_cnode->unit_id = cnode->unit_id;
|
|
|
1913 new_cnode->merged_comdat = cnode->merged_comdat;
|
|
|
1914 new_cnode->merged_extern_inline = cnode->merged_extern_inline;
|
|
111
|
1915 }
|
|
|
1916 else
|
|
|
1917 {
|
|
|
1918 TREE_READONLY (new_decl) = TREE_READONLY (node->decl);
|
|
|
1919 DECL_INITIAL (new_decl) = error_mark_node;
|
|
|
1920 new_node = varpool_node::create_alias (new_decl, node->decl);
|
|
|
1921 }
|
|
|
1922 new_node->resolve_alias (node);
|
|
|
1923 gcc_assert (decl_binds_to_current_def_p (new_decl)
|
|
|
1924 && targetm.binds_local_p (new_decl));
|
|
|
1925 return new_node;
|
|
|
1926 }
|
|
|
1927
|
|
|
1928 /* Return true if symtab node and TARGET represents
|
|
|
1929 semantically equivalent symbols. */
|
|
|
1930
|
|
|
1931 bool
|
|
|
1932 symtab_node::semantically_equivalent_p (symtab_node *target)
|
|
|
1933 {
|
|
|
1934 enum availability avail;
|
|
|
1935 symtab_node *ba;
|
|
|
1936 symtab_node *bb;
|
|
|
1937
|
|
|
1938 /* Equivalent functions are equivalent. */
|
|
|
1939 if (decl == target->decl)
|
|
|
1940 return true;
|
|
|
1941
|
|
|
1942 /* If symbol is not overwritable by different implementation,
|
|
|
1943 walk to the base object it defines. */
|
|
|
1944 ba = ultimate_alias_target (&avail);
|
|
|
1945 if (avail >= AVAIL_AVAILABLE)
|
|
|
1946 {
|
|
|
1947 if (target == ba)
|
|
|
1948 return true;
|
|
|
1949 }
|
|
|
1950 else
|
|
|
1951 ba = this;
|
|
|
1952 bb = target->ultimate_alias_target (&avail);
|
|
|
1953 if (avail >= AVAIL_AVAILABLE)
|
|
|
1954 {
|
|
|
1955 if (this == bb)
|
|
|
1956 return true;
|
|
|
1957 }
|
|
|
1958 else
|
|
|
1959 bb = target;
|
|
|
1960 return bb == ba;
|
|
|
1961 }
|
|
|
1962
|
|
|
1963 /* Classify symbol symtab node for partitioning. */
|
|
|
1964
|
|
|
1965 enum symbol_partitioning_class
|
|
|
1966 symtab_node::get_partitioning_class (void)
|
|
|
1967 {
|
|
|
1968 /* Inline clones are always duplicated.
|
|
145
|
1969 This include external declarations. */
|
|
111
|
1970 cgraph_node *cnode = dyn_cast <cgraph_node *> (this);
|
|
|
1971
|
|
|
1972 if (DECL_ABSTRACT_P (decl))
|
|
|
1973 return SYMBOL_EXTERNAL;
|
|
|
1974
|
|
145
|
1975 if (cnode && cnode->inlined_to)
|
|
111
|
1976 return SYMBOL_DUPLICATE;
|
|
|
1977
|
|
|
1978 /* Transparent aliases are always duplicated. */
|
|
|
1979 if (transparent_alias)
|
|
|
1980 return definition ? SYMBOL_DUPLICATE : SYMBOL_EXTERNAL;
|
|
|
1981
|
|
|
1982 /* External declarations are external. */
|
|
|
1983 if (DECL_EXTERNAL (decl))
|
|
|
1984 return SYMBOL_EXTERNAL;
|
|
|
1985
|
|
145
|
1986 /* Even static aliases of external functions as external. Those can happen
|
|
|
1987 when COMDAT got resolved to non-IL implementation. */
|
|
|
1988 if (alias && DECL_EXTERNAL (ultimate_alias_target ()->decl))
|
|
|
1989 return SYMBOL_EXTERNAL;
|
|
|
1990
|
|
111
|
1991 if (varpool_node *vnode = dyn_cast <varpool_node *> (this))
|
|
|
1992 {
|
|
|
1993 if (alias && definition && !ultimate_alias_target ()->definition)
|
|
|
1994 return SYMBOL_EXTERNAL;
|
|
145
|
1995 /* Constant pool references use local symbol names that cannot
|
|
111
|
1996 be promoted global. We should never put into a constant pool
|
|
145
|
1997 objects that cannot be duplicated across partitions. */
|
|
111
|
1998 if (DECL_IN_CONSTANT_POOL (decl))
|
|
|
1999 return SYMBOL_DUPLICATE;
|
|
|
2000 if (DECL_HARD_REGISTER (decl))
|
|
|
2001 return SYMBOL_DUPLICATE;
|
|
|
2002 gcc_checking_assert (vnode->definition);
|
|
|
2003 }
|
|
|
2004 /* Functions that are cloned may stay in callgraph even if they are unused.
|
|
|
2005 Handle them as external; compute_ltrans_boundary take care to make
|
|
|
2006 proper things to happen (i.e. to make them appear in the boundary but
|
|
|
2007 with body streamed, so clone can me materialized). */
|
|
|
2008 else if (!dyn_cast <cgraph_node *> (this)->function_symbol ()->definition)
|
|
|
2009 return SYMBOL_EXTERNAL;
|
|
|
2010
|
|
|
2011 /* Linker discardable symbols are duplicated to every use unless they are
|
|
|
2012 keyed. */
|
|
|
2013 if (DECL_ONE_ONLY (decl)
|
|
|
2014 && !force_output
|
|
|
2015 && !forced_by_abi
|
|
|
2016 && !used_from_object_file_p ())
|
|
|
2017 return SYMBOL_DUPLICATE;
|
|
|
2018
|
|
|
2019 return SYMBOL_PARTITION;
|
|
|
2020 }
|
|
|
2021
|
|
|
2022 /* Return true when symbol is known to be non-zero. */
|
|
|
2023
|
|
|
2024 bool
|
|
|
2025 symtab_node::nonzero_address ()
|
|
|
2026 {
|
|
|
2027 /* Weakrefs may be NULL when their target is not defined. */
|
|
|
2028 if (alias && weakref)
|
|
|
2029 {
|
|
|
2030 if (analyzed)
|
|
|
2031 {
|
|
|
2032 symtab_node *target = ultimate_alias_target ();
|
|
|
2033
|
|
|
2034 if (target->alias && target->weakref)
|
|
|
2035 return false;
|
|
145
|
2036 /* We cannot recurse to target::nonzero. It is possible that the
|
|
111
|
2037 target is used only via the alias.
|
|
|
2038 We may walk references and look for strong use, but we do not know
|
|
|
2039 if this strong use will survive to final binary, so be
|
|
|
2040 conservative here.
|
|
|
2041 ??? Maybe we could do the lookup during late optimization that
|
|
|
2042 could be useful to eliminate the NULL pointer checks in LTO
|
|
|
2043 programs. */
|
|
|
2044 if (target->definition && !DECL_EXTERNAL (target->decl))
|
|
|
2045 return true;
|
|
|
2046 if (target->resolution != LDPR_UNKNOWN
|
|
|
2047 && target->resolution != LDPR_UNDEF
|
|
|
2048 && !target->can_be_discarded_p ()
|
|
|
2049 && flag_delete_null_pointer_checks)
|
|
|
2050 return true;
|
|
|
2051 return false;
|
|
|
2052 }
|
|
|
2053 else
|
|
|
2054 return false;
|
|
|
2055 }
|
|
|
2056
|
|
|
2057 /* With !flag_delete_null_pointer_checks we assume that symbols may
|
|
|
2058 bind to NULL. This is on by default on embedded targets only.
|
|
|
2059
|
|
|
2060 Otherwise all non-WEAK symbols must be defined and thus non-NULL or
|
|
145
|
2061 linking fails. Important case of WEAK we want to do well are comdats,
|
|
|
2062 which also must be defined somewhere.
|
|
111
|
2063
|
|
|
2064 When parsing, beware the cases when WEAK attribute is added later. */
|
|
145
|
2065 if ((!DECL_WEAK (decl) || DECL_COMDAT (decl))
|
|
111
|
2066 && flag_delete_null_pointer_checks)
|
|
|
2067 {
|
|
|
2068 refuse_visibility_changes = true;
|
|
|
2069 return true;
|
|
|
2070 }
|
|
|
2071
|
|
145
|
2072 /* If target is defined and not extern, we know it will be
|
|
131
|
2073 output and thus it will bind to non-NULL.
|
|
|
2074 Play safe for flag_delete_null_pointer_checks where weak definition may
|
|
111
|
2075 be re-defined by NULL. */
|
|
145
|
2076 if (definition && !DECL_EXTERNAL (decl)
|
|
111
|
2077 && (flag_delete_null_pointer_checks || !DECL_WEAK (decl)))
|
|
|
2078 {
|
|
|
2079 if (!DECL_WEAK (decl))
|
|
|
2080 refuse_visibility_changes = true;
|
|
|
2081 return true;
|
|
|
2082 }
|
|
|
2083
|
|
|
2084 /* As the last resort, check the resolution info. */
|
|
|
2085 if (resolution != LDPR_UNKNOWN
|
|
|
2086 && resolution != LDPR_UNDEF
|
|
|
2087 && !can_be_discarded_p ()
|
|
|
2088 && flag_delete_null_pointer_checks)
|
|
|
2089 return true;
|
|
|
2090 return false;
|
|
|
2091 }
|
|
|
2092
|
|
|
2093 /* Return 0 if symbol is known to have different address than S2,
|
|
|
2094 Return 1 if symbol is known to have same address as S2,
|
|
|
2095 return -1 otherwise.
|
|
|
2096
|
|
|
2097 If MEMORY_ACCESSED is true, assume that both memory pointer to THIS
|
|
|
2098 and S2 is going to be accessed. This eliminates the situations when
|
|
145
|
2099 either THIS or S2 is NULL and is useful for comparing bases when deciding
|
|
111
|
2100 about memory aliasing. */
|
|
|
2101 int
|
|
|
2102 symtab_node::equal_address_to (symtab_node *s2, bool memory_accessed)
|
|
|
2103 {
|
|
|
2104 enum availability avail1, avail2;
|
|
|
2105
|
|
|
2106 /* A Shortcut: equivalent symbols are always equivalent. */
|
|
|
2107 if (this == s2)
|
|
|
2108 return 1;
|
|
|
2109
|
|
|
2110 /* Unwind transparent aliases first; those are always equal to their
|
|
|
2111 target. */
|
|
|
2112 if (this->transparent_alias && this->analyzed)
|
|
|
2113 return this->get_alias_target ()->equal_address_to (s2);
|
|
|
2114 while (s2->transparent_alias && s2->analyzed)
|
|
|
2115 s2 = s2->get_alias_target();
|
|
|
2116
|
|
|
2117 if (this == s2)
|
|
|
2118 return 1;
|
|
|
2119
|
|
|
2120 /* For non-interposable aliases, lookup and compare their actual definitions.
|
|
|
2121 Also check if the symbol needs to bind to given definition. */
|
|
|
2122 symtab_node *rs1 = ultimate_alias_target (&avail1);
|
|
|
2123 symtab_node *rs2 = s2->ultimate_alias_target (&avail2);
|
|
|
2124 bool binds_local1 = rs1->analyzed && decl_binds_to_current_def_p (this->decl);
|
|
|
2125 bool binds_local2 = rs2->analyzed && decl_binds_to_current_def_p (s2->decl);
|
|
|
2126 bool really_binds_local1 = binds_local1;
|
|
|
2127 bool really_binds_local2 = binds_local2;
|
|
|
2128
|
|
145
|
2129 /* Addresses of vtables and virtual functions cannot be used by user
|
|
111
|
2130 code and are used only within speculation. In this case we may make
|
|
|
2131 symbol equivalent to its alias even if interposition may break this
|
|
|
2132 rule. Doing so will allow us to turn speculative inlining into
|
|
145
|
2133 non-speculative more aggressively. */
|
|
111
|
2134 if (DECL_VIRTUAL_P (this->decl) && avail1 >= AVAIL_AVAILABLE)
|
|
|
2135 binds_local1 = true;
|
|
|
2136 if (DECL_VIRTUAL_P (s2->decl) && avail2 >= AVAIL_AVAILABLE)
|
|
|
2137 binds_local2 = true;
|
|
|
2138
|
|
|
2139 /* If both definitions are available we know that even if they are bound
|
|
|
2140 to other unit they must be defined same way and therefore we can use
|
|
|
2141 equivalence test. */
|
|
|
2142 if (rs1 != rs2 && avail1 >= AVAIL_AVAILABLE && avail2 >= AVAIL_AVAILABLE)
|
|
|
2143 binds_local1 = binds_local2 = true;
|
|
|
2144
|
|
|
2145 if (binds_local1 && binds_local2 && rs1 == rs2)
|
|
|
2146 {
|
|
|
2147 /* We made use of the fact that alias is not weak. */
|
|
|
2148 if (rs1 != this)
|
|
|
2149 refuse_visibility_changes = true;
|
|
|
2150 if (rs2 != s2)
|
|
|
2151 s2->refuse_visibility_changes = true;
|
|
|
2152 return 1;
|
|
|
2153 }
|
|
|
2154
|
|
145
|
2155 /* If both symbols may resolve to NULL, we cannot really prove them
|
|
111
|
2156 different. */
|
|
|
2157 if (!memory_accessed && !nonzero_address () && !s2->nonzero_address ())
|
|
|
2158 return -1;
|
|
|
2159
|
|
|
2160 /* Except for NULL, functions and variables never overlap. */
|
|
|
2161 if (TREE_CODE (decl) != TREE_CODE (s2->decl))
|
|
|
2162 return 0;
|
|
|
2163
|
|
|
2164 /* If one of the symbols is unresolved alias, punt. */
|
|
|
2165 if (rs1->alias || rs2->alias)
|
|
|
2166 return -1;
|
|
|
2167
|
|
|
2168 /* If we have a non-interposale definition of at least one of the symbols
|
|
145
|
2169 and the other symbol is different, we know other unit cannot interpose
|
|
111
|
2170 it to the first symbol; all aliases of the definition needs to be
|
|
|
2171 present in the current unit. */
|
|
|
2172 if (((really_binds_local1 || really_binds_local2)
|
|
|
2173 /* If we have both definitions and they are different, we know they
|
|
|
2174 will be different even in units they binds to. */
|
|
|
2175 || (binds_local1 && binds_local2))
|
|
|
2176 && rs1 != rs2)
|
|
|
2177 {
|
|
|
2178 /* We make use of the fact that one symbol is not alias of the other
|
|
|
2179 and that the definition is non-interposable. */
|
|
|
2180 refuse_visibility_changes = true;
|
|
|
2181 s2->refuse_visibility_changes = true;
|
|
|
2182 rs1->refuse_visibility_changes = true;
|
|
|
2183 rs2->refuse_visibility_changes = true;
|
|
|
2184 return 0;
|
|
|
2185 }
|
|
|
2186
|
|
|
2187 /* TODO: Alias oracle basically assume that addresses of global variables
|
|
|
2188 are different unless they are declared as alias of one to another while
|
|
145
|
2189 the code folding comparisons doesn't.
|
|
111
|
2190 We probably should be consistent and use this fact here, too, but for
|
|
|
2191 the moment return false only when we are called from the alias oracle. */
|
|
|
2192
|
|
|
2193 return memory_accessed && rs1 != rs2 ? 0 : -1;
|
|
|
2194 }
|
|
|
2195
|
|
|
2196 /* Worker for call_for_symbol_and_aliases. */
|
|
|
2197
|
|
|
2198 bool
|
|
|
2199 symtab_node::call_for_symbol_and_aliases_1 (bool (*callback) (symtab_node *,
|
|
|
2200 void *),
|
|
|
2201 void *data,
|
|
|
2202 bool include_overwritable)
|
|
|
2203 {
|
|
|
2204 ipa_ref *ref;
|
|
|
2205 FOR_EACH_ALIAS (this, ref)
|
|
|
2206 {
|
|
|
2207 symtab_node *alias = ref->referring;
|
|
|
2208 if (include_overwritable
|
|
|
2209 || alias->get_availability () > AVAIL_INTERPOSABLE)
|
|
|
2210 if (alias->call_for_symbol_and_aliases (callback, data,
|
|
|
2211 include_overwritable))
|
|
|
2212 return true;
|
|
|
2213 }
|
|
|
2214 return false;
|
|
|
2215 }
|
|
|
2216
|
|
|
2217 /* Return true if address of N is possibly compared. */
|
|
|
2218
|
|
|
2219 static bool
|
|
|
2220 address_matters_1 (symtab_node *n, void *)
|
|
|
2221 {
|
|
|
2222 struct ipa_ref *ref;
|
|
|
2223
|
|
|
2224 if (!n->address_can_be_compared_p ())
|
|
|
2225 return false;
|
|
|
2226 if (n->externally_visible || n->force_output)
|
|
|
2227 return true;
|
|
|
2228
|
|
|
2229 for (unsigned int i = 0; n->iterate_referring (i, ref); i++)
|
|
|
2230 if (ref->address_matters_p ())
|
|
|
2231 return true;
|
|
|
2232 return false;
|
|
|
2233 }
|
|
|
2234
|
|
|
2235 /* Return true if symbol's address may possibly be compared to other
|
|
|
2236 symbol's address. */
|
|
|
2237
|
|
|
2238 bool
|
|
|
2239 symtab_node::address_matters_p ()
|
|
|
2240 {
|
|
|
2241 gcc_assert (!alias);
|
|
|
2242 return call_for_symbol_and_aliases (address_matters_1, NULL, true);
|
|
|
2243 }
|
|
|
2244
|
|
|
2245 /* Return true if symbol's alignment may be increased. */
|
|
|
2246
|
|
|
2247 bool
|
|
|
2248 symtab_node::can_increase_alignment_p (void)
|
|
|
2249 {
|
|
|
2250 symtab_node *target = ultimate_alias_target ();
|
|
|
2251
|
|
|
2252 /* For now support only variables. */
|
|
|
2253 if (!VAR_P (decl))
|
|
|
2254 return false;
|
|
|
2255
|
|
|
2256 /* With -fno-toplevel-reorder we may have already output the constant. */
|
|
|
2257 if (TREE_ASM_WRITTEN (target->decl))
|
|
|
2258 return false;
|
|
|
2259
|
|
145
|
2260 /* If target is already placed in an anchor, we cannot touch its
|
|
111
|
2261 alignment. */
|
|
|
2262 if (DECL_RTL_SET_P (target->decl)
|
|
|
2263 && MEM_P (DECL_RTL (target->decl))
|
|
|
2264 && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (DECL_RTL (target->decl), 0)))
|
|
|
2265 return false;
|
|
|
2266
|
|
|
2267 /* Constant pool entries may be shared. */
|
|
|
2268 if (DECL_IN_CONSTANT_POOL (target->decl))
|
|
|
2269 return false;
|
|
|
2270
|
|
|
2271 /* We cannot change alignment of symbols that may bind to symbols
|
|
|
2272 in other translation unit that may contain a definition with lower
|
|
|
2273 alignment. */
|
|
|
2274 if (!decl_binds_to_current_def_p (decl))
|
|
|
2275 return false;
|
|
|
2276
|
|
|
2277 /* When compiling partition, be sure the symbol is not output by other
|
|
|
2278 partition. */
|
|
|
2279 if (flag_ltrans
|
|
|
2280 && (target->in_other_partition
|
|
|
2281 || target->get_partitioning_class () == SYMBOL_DUPLICATE))
|
|
|
2282 return false;
|
|
|
2283
|
|
|
2284 /* Do not override the alignment as specified by the ABI when the used
|
|
|
2285 attribute is set. */
|
|
|
2286 if (DECL_PRESERVE_P (decl) || DECL_PRESERVE_P (target->decl))
|
|
|
2287 return false;
|
|
|
2288
|
|
|
2289 /* Do not override explicit alignment set by the user when an explicit
|
|
|
2290 section name is also used. This is a common idiom used by many
|
|
|
2291 software projects. */
|
|
|
2292 if (DECL_SECTION_NAME (target->decl) != NULL && !target->implicit_section)
|
|
|
2293 return false;
|
|
|
2294
|
|
|
2295 return true;
|
|
|
2296 }
|
|
|
2297
|
|
|
2298 /* Worker for symtab_node::increase_alignment. */
|
|
|
2299
|
|
|
2300 static bool
|
|
|
2301 increase_alignment_1 (symtab_node *n, void *v)
|
|
|
2302 {
|
|
|
2303 unsigned int align = (size_t)v;
|
|
|
2304 if (DECL_ALIGN (n->decl) < align
|
|
|
2305 && n->can_increase_alignment_p ())
|
|
|
2306 {
|
|
|
2307 SET_DECL_ALIGN (n->decl, align);
|
|
|
2308 DECL_USER_ALIGN (n->decl) = 1;
|
|
|
2309 }
|
|
|
2310 return false;
|
|
|
2311 }
|
|
|
2312
|
|
|
2313 /* Increase alignment of THIS to ALIGN. */
|
|
|
2314
|
|
|
2315 void
|
|
|
2316 symtab_node::increase_alignment (unsigned int align)
|
|
|
2317 {
|
|
131
|
2318 gcc_assert (can_increase_alignment_p () && align <= MAX_OFILE_ALIGNMENT);
|
|
111
|
2319 ultimate_alias_target()->call_for_symbol_and_aliases (increase_alignment_1,
|
|
|
2320 (void *)(size_t) align,
|
|
|
2321 true);
|
|
|
2322 gcc_assert (DECL_ALIGN (decl) >= align);
|
|
|
2323 }
|
|
|
2324
|
|
|
2325 /* Helper for symtab_node::definition_alignment. */
|
|
|
2326
|
|
|
2327 static bool
|
|
|
2328 get_alignment_1 (symtab_node *n, void *v)
|
|
|
2329 {
|
|
|
2330 *((unsigned int *)v) = MAX (*((unsigned int *)v), DECL_ALIGN (n->decl));
|
|
|
2331 return false;
|
|
|
2332 }
|
|
|
2333
|
|
|
2334 /* Return desired alignment of the definition. This is NOT alignment useful
|
|
|
2335 to access THIS, because THIS may be interposable and DECL_ALIGN should
|
|
|
2336 be used instead. It however must be guaranteed when output definition
|
|
|
2337 of THIS. */
|
|
|
2338
|
|
|
2339 unsigned int
|
|
|
2340 symtab_node::definition_alignment ()
|
|
|
2341 {
|
|
|
2342 unsigned int align = 0;
|
|
|
2343 gcc_assert (!alias);
|
|
|
2344 call_for_symbol_and_aliases (get_alignment_1, &align, true);
|
|
|
2345 return align;
|
|
|
2346 }
|
|
|
2347
|
|
|
2348 /* Return symbol used to separate symbol name from suffix. */
|
|
|
2349
|
|
|
2350 char
|
|
|
2351 symbol_table::symbol_suffix_separator ()
|
|
|
2352 {
|
|
|
2353 #ifndef NO_DOT_IN_LABEL
|
|
|
2354 return '.';
|
|
|
2355 #elif !defined NO_DOLLAR_IN_LABEL
|
|
|
2356 return '$';
|
|
|
2357 #else
|
|
|
2358 return '_';
|
|
|
2359 #endif
|
|
|
2360 }
|
|
|
2361
|
|
|
2362 /* Return true when references to this symbol from REF must bind to current
|
|
|
2363 definition in final executable. */
|
|
|
2364
|
|
|
2365 bool
|
|
|
2366 symtab_node::binds_to_current_def_p (symtab_node *ref)
|
|
|
2367 {
|
|
|
2368 if (!definition)
|
|
|
2369 return false;
|
|
|
2370 if (transparent_alias)
|
|
|
2371 return definition
|
|
|
2372 && get_alias_target()->binds_to_current_def_p (ref);
|
|
131
|
2373 cgraph_node *cnode = dyn_cast <cgraph_node *> (this);
|
|
|
2374 if (cnode && cnode->ifunc_resolver)
|
|
111
|
2375 return false;
|
|
|
2376 if (decl_binds_to_current_def_p (decl))
|
|
|
2377 return true;
|
|
|
2378
|
|
|
2379 /* Inline clones always binds locally. */
|
|
145
|
2380 if (cnode && cnode->inlined_to)
|
|
111
|
2381 return true;
|
|
|
2382
|
|
|
2383 if (DECL_EXTERNAL (decl))
|
|
|
2384 return false;
|
|
|
2385
|
|
|
2386 gcc_assert (externally_visible);
|
|
|
2387
|
|
|
2388 if (ref)
|
|
|
2389 {
|
|
|
2390 cgraph_node *cref = dyn_cast <cgraph_node *> (ref);
|
|
|
2391 if (cref)
|
|
145
|
2392 ref = cref->inlined_to;
|
|
111
|
2393 }
|
|
|
2394
|
|
|
2395 /* If this is a reference from symbol itself and there are no aliases, we
|
|
|
2396 may be sure that the symbol was not interposed by something else because
|
|
|
2397 the symbol itself would be unreachable otherwise. This is important
|
|
|
2398 to optimize recursive functions well.
|
|
|
2399
|
|
|
2400 This assumption may be broken by inlining: if symbol is interposable
|
|
|
2401 but the body is available (i.e. declared inline), inliner may make
|
|
|
2402 the body reachable even with interposition. */
|
|
|
2403 if (this == ref && !has_aliases_p ()
|
|
|
2404 && (!cnode
|
|
|
2405 || symtab->state >= IPA_SSA_AFTER_INLINING
|
|
|
2406 || get_availability () >= AVAIL_INTERPOSABLE))
|
|
|
2407 return true;
|
|
|
2408
|
|
|
2409
|
|
|
2410 /* References within one comdat group are always bound in a group. */
|
|
|
2411 if (ref
|
|
|
2412 && symtab->state >= IPA_SSA_AFTER_INLINING
|
|
|
2413 && get_comdat_group ()
|
|
|
2414 && get_comdat_group () == ref->get_comdat_group ())
|
|
|
2415 return true;
|
|
|
2416
|
|
|
2417 return false;
|
|
|
2418 }
|
|
131
|
2419
|
|
|
2420 /* Return true if symbol should be output to the symbol table. */
|
|
|
2421
|
|
|
2422 bool
|
|
|
2423 symtab_node::output_to_lto_symbol_table_p (void)
|
|
|
2424 {
|
|
|
2425 /* Only externally visible symbols matter. */
|
|
|
2426 if (!TREE_PUBLIC (decl))
|
|
|
2427 return false;
|
|
|
2428 if (!real_symbol_p ())
|
|
|
2429 return false;
|
|
|
2430 /* FIXME: variables probably should not be considered as real symbols at
|
|
|
2431 first place. */
|
|
|
2432 if (VAR_P (decl) && DECL_HARD_REGISTER (decl))
|
|
|
2433 return false;
|
|
145
|
2434 if (TREE_CODE (decl) == FUNCTION_DECL && !definition
|
|
|
2435 && fndecl_built_in_p (decl))
|
|
|
2436 {
|
|
|
2437 /* Builtins like those for most math functions have actual implementations
|
|
|
2438 in libraries so make sure to output references into the symbol table to
|
|
|
2439 make those libraries referenced. Note this is incomplete handling for
|
|
|
2440 now and only covers math functions. */
|
|
|
2441 if (builtin_with_linkage_p (decl))
|
|
|
2442 return true;
|
|
|
2443 else
|
|
|
2444 return false;
|
|
|
2445 }
|
|
131
|
2446
|
|
|
2447 /* We have real symbol that should be in symbol table. However try to trim
|
|
145
|
2448 down the references to libraries bit more because linker will otherwise
|
|
|
2449 bring unnecessary object files into the final link.
|
|
131
|
2450 FIXME: The following checks can easily be confused i.e. by self recursive
|
|
|
2451 function or self-referring variable. */
|
|
|
2452
|
|
|
2453 /* We keep external functions in symtab for sake of inlining
|
|
|
2454 and devirtualization. We do not want to see them in symbol table as
|
|
|
2455 references unless they are really used. */
|
|
|
2456 cgraph_node *cnode = dyn_cast <cgraph_node *> (this);
|
|
|
2457 if (cnode && (!definition || DECL_EXTERNAL (decl))
|
|
|
2458 && cnode->callers)
|
|
|
2459 return true;
|
|
|
2460
|
|
|
2461 /* Ignore all references from external vars initializers - they are not really
|
|
|
2462 part of the compilation unit until they are used by folding. Some symbols,
|
|
145
|
2463 like references to external construction vtables cannot be referred to at
|
|
131
|
2464 all. We decide this at can_refer_decl_in_current_unit_p. */
|
|
|
2465 if (!definition || DECL_EXTERNAL (decl))
|
|
|
2466 {
|
|
|
2467 int i;
|
|
|
2468 struct ipa_ref *ref;
|
|
|
2469 for (i = 0; iterate_referring (i, ref); i++)
|
|
|
2470 {
|
|
|
2471 if (ref->use == IPA_REF_ALIAS)
|
|
|
2472 continue;
|
|
|
2473 if (is_a <cgraph_node *> (ref->referring))
|
|
|
2474 return true;
|
|
|
2475 if (!DECL_EXTERNAL (ref->referring->decl))
|
|
|
2476 return true;
|
|
|
2477 }
|
|
|
2478 return false;
|
|
|
2479 }
|
|
|
2480 return true;
|
|
|
2481 }
|
