?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
PR sanitizer/59009
[official-gcc.git] / gcc / lto / lto.c
blob62856d085b7a6477d5ad5403f038c273c1c1ccdf
1 /* Top-level LTO routines.
2 Copyright (C) 2009-2013 Free Software Foundation, Inc.
3 Contributed by CodeSourcery, Inc.
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 "opts.h"
25 #include "toplev.h"
26 #include "tree.h"
27 #include "diagnostic-core.h"
28 #include "tm.h"
29 #include "cgraph.h"
30 #include "ggc.h"
31 #include "tree-ssa-operands.h"
32 #include "tree-pass.h"
33 #include "langhooks.h"
34 #include "vec.h"
35 #include "bitmap.h"
36 #include "pointer-set.h"
37 #include "ipa-prop.h"
38 #include "common.h"
39 #include "debug.h"
40 #include "gimple.h"
41 #include "lto.h"
42 #include "lto-tree.h"
43 #include "lto-streamer.h"
44 #include "tree-streamer.h"
45 #include "splay-tree.h"
46 #include "lto-partition.h"
47 #include "data-streamer.h"
48 #include "context.h"
49 #include "pass_manager.h"
50
51 /* Vector to keep track of external variables we've seen so far. */
52 vec<tree, va_gc> *lto_global_var_decls;
53
54 static GTY(()) tree first_personality_decl;
55
56 /* Returns a hash code for P. */
57
58 static hashval_t
59 hash_name (const void *p)
60 {
61 const struct lto_section_slot *ds = (const struct lto_section_slot *) p;
62 return (hashval_t) htab_hash_string (ds->name);
63 }
64
65
66 /* Returns nonzero if P1 and P2 are equal. */
67
68 static int
69 eq_name (const void *p1, const void *p2)
70 {
71 const struct lto_section_slot *s1 =
72 (const struct lto_section_slot *) p1;
73 const struct lto_section_slot *s2 =
74 (const struct lto_section_slot *) p2;
75
76 return strcmp (s1->name, s2->name) == 0;
77 }
78
79 /* Free lto_section_slot */
80
81 static void
82 free_with_string (void *arg)
83 {
84 struct lto_section_slot *s = (struct lto_section_slot *)arg;
85
86 free (CONST_CAST (char *, s->name));
87 free (arg);
88 }
89
90 /* Create section hash table */
91
92 htab_t
93 lto_obj_create_section_hash_table (void)
94 {
95 return htab_create (37, hash_name, eq_name, free_with_string);
96 }
97
98 /* Delete an allocated integer KEY in the splay tree. */
99
100 static void
101 lto_splay_tree_delete_id (splay_tree_key key)
102 {
103 free ((void *) key);
104 }
105
106 /* Compare splay tree node ids A and B. */
107
108 static int
109 lto_splay_tree_compare_ids (splay_tree_key a, splay_tree_key b)
110 {
111 unsigned HOST_WIDE_INT ai;
112 unsigned HOST_WIDE_INT bi;
113
114 ai = *(unsigned HOST_WIDE_INT *) a;
115 bi = *(unsigned HOST_WIDE_INT *) b;
116
117 if (ai < bi)
118 return -1;
119 else if (ai > bi)
120 return 1;
121 return 0;
122 }
123
124 /* Look up splay tree node by ID in splay tree T. */
125
126 static splay_tree_node
127 lto_splay_tree_lookup (splay_tree t, unsigned HOST_WIDE_INT id)
128 {
129 return splay_tree_lookup (t, (splay_tree_key) &id);
130 }
131
132 /* Check if KEY has ID. */
133
134 static bool
135 lto_splay_tree_id_equal_p (splay_tree_key key, unsigned HOST_WIDE_INT id)
136 {
137 return *(unsigned HOST_WIDE_INT *) key == id;
138 }
139
140 /* Insert a splay tree node into tree T with ID as key and FILE_DATA as value.
141 The ID is allocated separately because we need HOST_WIDE_INTs which may
142 be wider than a splay_tree_key. */
143
144 static void
145 lto_splay_tree_insert (splay_tree t, unsigned HOST_WIDE_INT id,
146 struct lto_file_decl_data *file_data)
147 {
148 unsigned HOST_WIDE_INT *idp = XCNEW (unsigned HOST_WIDE_INT);
149 *idp = id;
150 splay_tree_insert (t, (splay_tree_key) idp, (splay_tree_value) file_data);
151 }
152
153 /* Create a splay tree. */
154
155 static splay_tree
156 lto_splay_tree_new (void)
157 {
158 return splay_tree_new (lto_splay_tree_compare_ids,
159 lto_splay_tree_delete_id,
160 NULL);
161 }
162
163 /* Return true when NODE has a clone that is analyzed (i.e. we need
164 to load its body even if the node itself is not needed). */
165
166 static bool
167 has_analyzed_clone_p (struct cgraph_node *node)
168 {
169 struct cgraph_node *orig = node;
170 node = node->clones;
171 if (node)
172 while (node != orig)
173 {
174 if (node->analyzed)
175 return true;
176 if (node->clones)
177 node = node->clones;
178 else if (node->next_sibling_clone)
179 node = node->next_sibling_clone;
180 else
181 {
182 while (node != orig && !node->next_sibling_clone)
183 node = node->clone_of;
184 if (node != orig)
185 node = node->next_sibling_clone;
186 }
187 }
188 return false;
189 }
190
191 /* Read the function body for the function associated with NODE. */
192
193 static void
194 lto_materialize_function (struct cgraph_node *node)
195 {
196 tree decl;
197
198 decl = node->decl;
199 /* Read in functions with body (analyzed nodes)
200 and also functions that are needed to produce virtual clones. */
201 if ((cgraph_function_with_gimple_body_p (node) && node->analyzed)
202 || node->used_as_abstract_origin
203 || has_analyzed_clone_p (node))
204 {
205 /* Clones don't need to be read. */
206 if (node->clone_of)
207 return;
208 if (DECL_FUNCTION_PERSONALITY (decl) && !first_personality_decl)
209 first_personality_decl = DECL_FUNCTION_PERSONALITY (decl);
210 }
211
212 /* Let the middle end know about the function. */
213 rest_of_decl_compilation (decl, 1, 0);
214 }
215
216
217 /* Decode the content of memory pointed to by DATA in the in decl
218 state object STATE. DATA_IN points to a data_in structure for
219 decoding. Return the address after the decoded object in the
220 input. */
221
222 static const uint32_t *
223 lto_read_in_decl_state (struct data_in *data_in, const uint32_t *data,
224 struct lto_in_decl_state *state)
225 {
226 uint32_t ix;
227 tree decl;
228 uint32_t i, j;
229
230 ix = *data++;
231 decl = streamer_tree_cache_get_tree (data_in->reader_cache, ix);
232 if (TREE_CODE (decl) != FUNCTION_DECL)
233 {
234 gcc_assert (decl == void_type_node);
235 decl = NULL_TREE;
236 }
237 state->fn_decl = decl;
238
239 for (i = 0; i < LTO_N_DECL_STREAMS; i++)
240 {
241 uint32_t size = *data++;
242 tree *decls = ggc_alloc_vec_tree (size);
243
244 for (j = 0; j < size; j++)
245 decls[j] = streamer_tree_cache_get_tree (data_in->reader_cache, data[j]);
246
247 state->streams[i].size = size;
248 state->streams[i].trees = decls;
249 data += size;
250 }
251
252 return data;
253 }
254
255
256 /* Global canonical type table. */
257 static htab_t gimple_canonical_types;
258 static pointer_map <hashval_t> *canonical_type_hash_cache;
259 static unsigned long num_canonical_type_hash_entries;
260 static unsigned long num_canonical_type_hash_queries;
261
262 static hashval_t iterative_hash_canonical_type (tree type, hashval_t val);
263 static hashval_t gimple_canonical_type_hash (const void *p);
264 static void gimple_register_canonical_type_1 (tree t, hashval_t hash);
265
266 /* Returning a hash value for gimple type TYPE.
267
268 The hash value returned is equal for types considered compatible
269 by gimple_canonical_types_compatible_p. */
270
271 static hashval_t
272 hash_canonical_type (tree type)
273 {
274 hashval_t v;
275
276 /* Combine a few common features of types so that types are grouped into
277 smaller sets; when searching for existing matching types to merge,
278 only existing types having the same features as the new type will be
279 checked. */
280 v = iterative_hash_hashval_t (TREE_CODE (type), 0);
281 v = iterative_hash_hashval_t (TREE_ADDRESSABLE (type), v);
282 v = iterative_hash_hashval_t (TYPE_ALIGN (type), v);
283 v = iterative_hash_hashval_t (TYPE_MODE (type), v);
284
285 /* Incorporate common features of numerical types. */
286 if (INTEGRAL_TYPE_P (type)
287 || SCALAR_FLOAT_TYPE_P (type)
288 || FIXED_POINT_TYPE_P (type)
289 || TREE_CODE (type) == OFFSET_TYPE
290 || POINTER_TYPE_P (type))
291 {
292 v = iterative_hash_hashval_t (TYPE_PRECISION (type), v);
293 v = iterative_hash_hashval_t (TYPE_UNSIGNED (type), v);
294 }
295
296 if (VECTOR_TYPE_P (type))
297 {
298 v = iterative_hash_hashval_t (TYPE_VECTOR_SUBPARTS (type), v);
299 v = iterative_hash_hashval_t (TYPE_UNSIGNED (type), v);
300 }
301
302 if (TREE_CODE (type) == COMPLEX_TYPE)
303 v = iterative_hash_hashval_t (TYPE_UNSIGNED (type), v);
304
305 /* For pointer and reference types, fold in information about the type
306 pointed to but do not recurse to the pointed-to type. */
307 if (POINTER_TYPE_P (type))
308 {
309 v = iterative_hash_hashval_t (TYPE_REF_CAN_ALIAS_ALL (type), v);
310 v = iterative_hash_hashval_t (TYPE_ADDR_SPACE (TREE_TYPE (type)), v);
311 v = iterative_hash_hashval_t (TYPE_RESTRICT (type), v);
312 v = iterative_hash_hashval_t (TREE_CODE (TREE_TYPE (type)), v);
313 }
314
315 /* For integer types hash only the string flag. */
316 if (TREE_CODE (type) == INTEGER_TYPE)
317 v = iterative_hash_hashval_t (TYPE_STRING_FLAG (type), v);
318
319 /* For array types hash the domain bounds and the string flag. */
320 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
321 {
322 v = iterative_hash_hashval_t (TYPE_STRING_FLAG (type), v);
323 /* OMP lowering can introduce error_mark_node in place of
324 random local decls in types. */
325 if (TYPE_MIN_VALUE (TYPE_DOMAIN (type)) != error_mark_node)
326 v = iterative_hash_expr (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), v);
327 if (TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != error_mark_node)
328 v = iterative_hash_expr (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), v);
329 }
330
331 /* Recurse for aggregates with a single element type. */
332 if (TREE_CODE (type) == ARRAY_TYPE
333 || TREE_CODE (type) == COMPLEX_TYPE
334 || TREE_CODE (type) == VECTOR_TYPE)
335 v = iterative_hash_canonical_type (TREE_TYPE (type), v);
336
337 /* Incorporate function return and argument types. */
338 if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
339 {
340 unsigned na;
341 tree p;
342
343 /* For method types also incorporate their parent class. */
344 if (TREE_CODE (type) == METHOD_TYPE)
345 v = iterative_hash_canonical_type (TYPE_METHOD_BASETYPE (type), v);
346
347 v = iterative_hash_canonical_type (TREE_TYPE (type), v);
348
349 for (p = TYPE_ARG_TYPES (type), na = 0; p; p = TREE_CHAIN (p))
350 {
351 v = iterative_hash_canonical_type (TREE_VALUE (p), v);
352 na++;
353 }
354
355 v = iterative_hash_hashval_t (na, v);
356 }
357
358 if (RECORD_OR_UNION_TYPE_P (type))
359 {
360 unsigned nf;
361 tree f;
362
363 for (f = TYPE_FIELDS (type), nf = 0; f; f = TREE_CHAIN (f))
364 if (TREE_CODE (f) == FIELD_DECL)
365 {
366 v = iterative_hash_canonical_type (TREE_TYPE (f), v);
367 nf++;
368 }
369
370 v = iterative_hash_hashval_t (nf, v);
371 }
372
373 return v;
374 }
375
376 /* Returning a hash value for gimple type TYPE combined with VAL. */
377
378 static hashval_t
379 iterative_hash_canonical_type (tree type, hashval_t val)
380 {
381 hashval_t v;
382 /* An already processed type. */
383 if (TYPE_CANONICAL (type))
384 {
385 type = TYPE_CANONICAL (type);
386 v = gimple_canonical_type_hash (type);
387 }
388 else
389 {
390 /* Canonical types should not be able to form SCCs by design, this
391 recursion is just because we do not register canonical types in
392 optimal order. To avoid quadratic behavior also register the
393 type here. */
394 v = hash_canonical_type (type);
395 gimple_register_canonical_type_1 (type, v);
396 }
397 return iterative_hash_hashval_t (v, val);
398 }
399
400 /* Returns the hash for a canonical type P. */
401
402 static hashval_t
403 gimple_canonical_type_hash (const void *p)
404 {
405 num_canonical_type_hash_queries++;
406 hashval_t *slot
407 = canonical_type_hash_cache->contains (CONST_CAST_TREE ((const_tree) p));
408 gcc_assert (slot != NULL);
409 return *slot;
410 }
411
412
413 /* The TYPE_CANONICAL merging machinery. It should closely resemble
414 the middle-end types_compatible_p function. It needs to avoid
415 claiming types are different for types that should be treated
416 the same with respect to TBAA. Canonical types are also used
417 for IL consistency checks via the useless_type_conversion_p
418 predicate which does not handle all type kinds itself but falls
419 back to pointer-comparison of TYPE_CANONICAL for aggregates
420 for example. */
421
422 /* Return true iff T1 and T2 are structurally identical for what
423 TBAA is concerned. */
424
425 static bool
426 gimple_canonical_types_compatible_p (tree t1, tree t2)
427 {
428 /* Before starting to set up the SCC machinery handle simple cases. */
429
430 /* Check first for the obvious case of pointer identity. */
431 if (t1 == t2)
432 return true;
433
434 /* Check that we have two types to compare. */
435 if (t1 == NULL_TREE || t2 == NULL_TREE)
436 return false;
437
438 /* If the types have been previously registered and found equal
439 they still are. */
440 if (TYPE_CANONICAL (t1)
441 && TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2))
442 return true;
443
444 /* Can't be the same type if the types don't have the same code. */
445 if (TREE_CODE (t1) != TREE_CODE (t2))
446 return false;
447
448 if (TREE_ADDRESSABLE (t1) != TREE_ADDRESSABLE (t2))
449 return false;
450
451 /* Qualifiers do not matter for canonical type comparison purposes. */
452
453 /* Void types and nullptr types are always the same. */
454 if (TREE_CODE (t1) == VOID_TYPE
455 || TREE_CODE (t1) == NULLPTR_TYPE)
456 return true;
457
458 /* Can't be the same type if they have different alignment, or mode. */
459 if (TYPE_ALIGN (t1) != TYPE_ALIGN (t2)
460 || TYPE_MODE (t1) != TYPE_MODE (t2))
461 return false;
462
463 /* Non-aggregate types can be handled cheaply. */
464 if (INTEGRAL_TYPE_P (t1)
465 || SCALAR_FLOAT_TYPE_P (t1)
466 || FIXED_POINT_TYPE_P (t1)
467 || TREE_CODE (t1) == VECTOR_TYPE
468 || TREE_CODE (t1) == COMPLEX_TYPE
469 || TREE_CODE (t1) == OFFSET_TYPE
470 || POINTER_TYPE_P (t1))
471 {
472 /* Can't be the same type if they have different sign or precision. */
473 if (TYPE_PRECISION (t1) != TYPE_PRECISION (t2)
474 || TYPE_UNSIGNED (t1) != TYPE_UNSIGNED (t2))
475 return false;
476
477 if (TREE_CODE (t1) == INTEGER_TYPE
478 && TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2))
479 return false;
480
481 /* For canonical type comparisons we do not want to build SCCs
482 so we cannot compare pointed-to types. But we can, for now,
483 require the same pointed-to type kind and match what
484 useless_type_conversion_p would do. */
485 if (POINTER_TYPE_P (t1))
486 {
487 /* If the two pointers have different ref-all attributes,
488 they can't be the same type. */
489 if (TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2))
490 return false;
491
492 if (TYPE_ADDR_SPACE (TREE_TYPE (t1))
493 != TYPE_ADDR_SPACE (TREE_TYPE (t2)))
494 return false;
495
496 if (TYPE_RESTRICT (t1) != TYPE_RESTRICT (t2))
497 return false;
498
499 if (TREE_CODE (TREE_TYPE (t1)) != TREE_CODE (TREE_TYPE (t2)))
500 return false;
501 }
502
503 /* Tail-recurse to components. */
504 if (TREE_CODE (t1) == VECTOR_TYPE
505 || TREE_CODE (t1) == COMPLEX_TYPE)
506 return gimple_canonical_types_compatible_p (TREE_TYPE (t1),
507 TREE_TYPE (t2));
508
509 return true;
510 }
511
512 /* Do type-specific comparisons. */
513 switch (TREE_CODE (t1))
514 {
515 case ARRAY_TYPE:
516 /* Array types are the same if the element types are the same and
517 the number of elements are the same. */
518 if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2))
519 || TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2)
520 || TYPE_NONALIASED_COMPONENT (t1) != TYPE_NONALIASED_COMPONENT (t2))
521 return false;
522 else
523 {
524 tree i1 = TYPE_DOMAIN (t1);
525 tree i2 = TYPE_DOMAIN (t2);
526
527 /* For an incomplete external array, the type domain can be
528 NULL_TREE. Check this condition also. */
529 if (i1 == NULL_TREE && i2 == NULL_TREE)
530 return true;
531 else if (i1 == NULL_TREE || i2 == NULL_TREE)
532 return false;
533 else
534 {
535 tree min1 = TYPE_MIN_VALUE (i1);
536 tree min2 = TYPE_MIN_VALUE (i2);
537 tree max1 = TYPE_MAX_VALUE (i1);
538 tree max2 = TYPE_MAX_VALUE (i2);
539
540 /* The minimum/maximum values have to be the same. */
541 if ((min1 == min2
542 || (min1 && min2
543 && ((TREE_CODE (min1) == PLACEHOLDER_EXPR
544 && TREE_CODE (min2) == PLACEHOLDER_EXPR)
545 || operand_equal_p (min1, min2, 0))))
546 && (max1 == max2
547 || (max1 && max2
548 && ((TREE_CODE (max1) == PLACEHOLDER_EXPR
549 && TREE_CODE (max2) == PLACEHOLDER_EXPR)
550 || operand_equal_p (max1, max2, 0)))))
551 return true;
552 else
553 return false;
554 }
555 }
556
557 case METHOD_TYPE:
558 case FUNCTION_TYPE:
559 /* Function types are the same if the return type and arguments types
560 are the same. */
561 if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
562 return false;
563
564 if (!comp_type_attributes (t1, t2))
565 return false;
566
567 if (TYPE_ARG_TYPES (t1) == TYPE_ARG_TYPES (t2))
568 return true;
569 else
570 {
571 tree parms1, parms2;
572
573 for (parms1 = TYPE_ARG_TYPES (t1), parms2 = TYPE_ARG_TYPES (t2);
574 parms1 && parms2;
575 parms1 = TREE_CHAIN (parms1), parms2 = TREE_CHAIN (parms2))
576 {
577 if (!gimple_canonical_types_compatible_p
578 (TREE_VALUE (parms1), TREE_VALUE (parms2)))
579 return false;
580 }
581
582 if (parms1 || parms2)
583 return false;
584
585 return true;
586 }
587
588 case RECORD_TYPE:
589 case UNION_TYPE:
590 case QUAL_UNION_TYPE:
591 {
592 tree f1, f2;
593
594 /* For aggregate types, all the fields must be the same. */
595 for (f1 = TYPE_FIELDS (t1), f2 = TYPE_FIELDS (t2);
596 f1 || f2;
597 f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2))
598 {
599 /* Skip non-fields. */
600 while (f1 && TREE_CODE (f1) != FIELD_DECL)
601 f1 = TREE_CHAIN (f1);
602 while (f2 && TREE_CODE (f2) != FIELD_DECL)
603 f2 = TREE_CHAIN (f2);
604 if (!f1 || !f2)
605 break;
606 /* The fields must have the same name, offset and type. */
607 if (DECL_NONADDRESSABLE_P (f1) != DECL_NONADDRESSABLE_P (f2)
608 || !gimple_compare_field_offset (f1, f2)
609 || !gimple_canonical_types_compatible_p
610 (TREE_TYPE (f1), TREE_TYPE (f2)))
611 return false;
612 }
613
614 /* If one aggregate has more fields than the other, they
615 are not the same. */
616 if (f1 || f2)
617 return false;
618
619 return true;
620 }
621
622 default:
623 gcc_unreachable ();
624 }
625 }
626
627
628 /* Returns nonzero if P1 and P2 are equal. */
629
630 static int
631 gimple_canonical_type_eq (const void *p1, const void *p2)
632 {
633 const_tree t1 = (const_tree) p1;
634 const_tree t2 = (const_tree) p2;
635 return gimple_canonical_types_compatible_p (CONST_CAST_TREE (t1),
636 CONST_CAST_TREE (t2));
637 }
638
639 /* Main worker for gimple_register_canonical_type. */
640
641 static void
642 gimple_register_canonical_type_1 (tree t, hashval_t hash)
643 {
644 void **slot;
645
646 gcc_checking_assert (TYPE_P (t) && !TYPE_CANONICAL (t));
647
648 slot = htab_find_slot_with_hash (gimple_canonical_types, t, hash, INSERT);
649 if (*slot)
650 {
651 tree new_type = (tree)(*slot);
652 gcc_checking_assert (new_type != t);
653 TYPE_CANONICAL (t) = new_type;
654 }
655 else
656 {
657 TYPE_CANONICAL (t) = t;
658 *slot = (void *) t;
659 /* Cache the just computed hash value. */
660 num_canonical_type_hash_entries++;
661 bool existed_p;
662 hashval_t *hslot = canonical_type_hash_cache->insert (t, &existed_p);
663 gcc_assert (!existed_p);
664 *hslot = hash;
665 }
666 }
667
668 /* Register type T in the global type table gimple_types and set
669 TYPE_CANONICAL of T accordingly.
670 This is used by LTO to merge structurally equivalent types for
671 type-based aliasing purposes across different TUs and languages.
672
673 ??? This merging does not exactly match how the tree.c middle-end
674 functions will assign TYPE_CANONICAL when new types are created
675 during optimization (which at least happens for pointer and array
676 types). */
677
678 static void
679 gimple_register_canonical_type (tree t)
680 {
681 if (TYPE_CANONICAL (t))
682 return;
683
684 gimple_register_canonical_type_1 (t, hash_canonical_type (t));
685 }
686
687 /* Re-compute TYPE_CANONICAL for NODE and related types. */
688
689 static void
690 lto_register_canonical_types (tree node, bool first_p)
691 {
692 if (!node
693 || !TYPE_P (node))
694 return;
695
696 if (first_p)
697 TYPE_CANONICAL (node) = NULL_TREE;
698
699 if (POINTER_TYPE_P (node)
700 || TREE_CODE (node) == COMPLEX_TYPE
701 || TREE_CODE (node) == ARRAY_TYPE)
702 lto_register_canonical_types (TREE_TYPE (node), first_p);
703
704 if (!first_p)
705 gimple_register_canonical_type (node);
706 }
707
708
709 /* Remember trees that contains references to declarations. */
710 static GTY(()) vec <tree, va_gc> *tree_with_vars;
711
712 #define CHECK_VAR(tt) \
713 do \
714 { \
715 if ((tt) && VAR_OR_FUNCTION_DECL_P (tt) \
716 && (TREE_PUBLIC (tt) || DECL_EXTERNAL (tt))) \
717 return true; \
718 } while (0)
719
720 #define CHECK_NO_VAR(tt) \
721 gcc_checking_assert (!(tt) || !VAR_OR_FUNCTION_DECL_P (tt))
722
723 /* Check presence of pointers to decls in fields of a tree_typed T. */
724
725 static inline bool
726 mentions_vars_p_typed (tree t)
727 {
728 CHECK_NO_VAR (TREE_TYPE (t));
729 return false;
730 }
731
732 /* Check presence of pointers to decls in fields of a tree_common T. */
733
734 static inline bool
735 mentions_vars_p_common (tree t)
736 {
737 if (mentions_vars_p_typed (t))
738 return true;
739 CHECK_NO_VAR (TREE_CHAIN (t));
740 return false;
741 }
742
743 /* Check presence of pointers to decls in fields of a decl_minimal T. */
744
745 static inline bool
746 mentions_vars_p_decl_minimal (tree t)
747 {
748 if (mentions_vars_p_common (t))
749 return true;
750 CHECK_NO_VAR (DECL_NAME (t));
751 CHECK_VAR (DECL_CONTEXT (t));
752 return false;
753 }
754
755 /* Check presence of pointers to decls in fields of a decl_common T. */
756
757 static inline bool
758 mentions_vars_p_decl_common (tree t)
759 {
760 if (mentions_vars_p_decl_minimal (t))
761 return true;
762 CHECK_VAR (DECL_SIZE (t));
763 CHECK_VAR (DECL_SIZE_UNIT (t));
764 CHECK_VAR (DECL_INITIAL (t));
765 CHECK_NO_VAR (DECL_ATTRIBUTES (t));
766 CHECK_VAR (DECL_ABSTRACT_ORIGIN (t));
767 return false;
768 }
769
770 /* Check presence of pointers to decls in fields of a decl_with_vis T. */
771
772 static inline bool
773 mentions_vars_p_decl_with_vis (tree t)
774 {
775 if (mentions_vars_p_decl_common (t))
776 return true;
777
778 /* Accessor macro has side-effects, use field-name here. */
779 CHECK_NO_VAR (t->decl_with_vis.assembler_name);
780 CHECK_NO_VAR (DECL_SECTION_NAME (t));
781 return false;
782 }
783
784 /* Check presence of pointers to decls in fields of a decl_non_common T. */
785
786 static inline bool
787 mentions_vars_p_decl_non_common (tree t)
788 {
789 if (mentions_vars_p_decl_with_vis (t))
790 return true;
791 CHECK_NO_VAR (DECL_ARGUMENT_FLD (t));
792 CHECK_NO_VAR (DECL_RESULT_FLD (t));
793 CHECK_NO_VAR (DECL_VINDEX (t));
794 return false;
795 }
796
797 /* Check presence of pointers to decls in fields of a decl_non_common T. */
798
799 static bool
800 mentions_vars_p_function (tree t)
801 {
802 if (mentions_vars_p_decl_non_common (t))
803 return true;
804 CHECK_VAR (DECL_FUNCTION_PERSONALITY (t));
805 return false;
806 }
807
808 /* Check presence of pointers to decls in fields of a field_decl T. */
809
810 static bool
811 mentions_vars_p_field_decl (tree t)
812 {
813 if (mentions_vars_p_decl_common (t))
814 return true;
815 CHECK_VAR (DECL_FIELD_OFFSET (t));
816 CHECK_NO_VAR (DECL_BIT_FIELD_TYPE (t));
817 CHECK_NO_VAR (DECL_QUALIFIER (t));
818 CHECK_NO_VAR (DECL_FIELD_BIT_OFFSET (t));
819 CHECK_NO_VAR (DECL_FCONTEXT (t));
820 return false;
821 }
822
823 /* Check presence of pointers to decls in fields of a type T. */
824
825 static bool
826 mentions_vars_p_type (tree t)
827 {
828 if (mentions_vars_p_common (t))
829 return true;
830 CHECK_NO_VAR (TYPE_CACHED_VALUES (t));
831 CHECK_VAR (TYPE_SIZE (t));
832 CHECK_VAR (TYPE_SIZE_UNIT (t));
833 CHECK_NO_VAR (TYPE_ATTRIBUTES (t));
834 CHECK_NO_VAR (TYPE_NAME (t));
835
836 CHECK_VAR (TYPE_MINVAL (t));
837 CHECK_VAR (TYPE_MAXVAL (t));
838
839 /* Accessor is for derived node types only. */
840 CHECK_NO_VAR (t->type_non_common.binfo);
841
842 CHECK_VAR (TYPE_CONTEXT (t));
843 CHECK_NO_VAR (TYPE_CANONICAL (t));
844 CHECK_NO_VAR (TYPE_MAIN_VARIANT (t));
845 CHECK_NO_VAR (TYPE_NEXT_VARIANT (t));
846 return false;
847 }
848
849 /* Check presence of pointers to decls in fields of a BINFO T. */
850
851 static bool
852 mentions_vars_p_binfo (tree t)
853 {
854 unsigned HOST_WIDE_INT i, n;
855
856 if (mentions_vars_p_common (t))
857 return true;
858 CHECK_VAR (BINFO_VTABLE (t));
859 CHECK_NO_VAR (BINFO_OFFSET (t));
860 CHECK_NO_VAR (BINFO_VIRTUALS (t));
861 CHECK_NO_VAR (BINFO_VPTR_FIELD (t));
862 n = vec_safe_length (BINFO_BASE_ACCESSES (t));
863 for (i = 0; i < n; i++)
864 CHECK_NO_VAR (BINFO_BASE_ACCESS (t, i));
865 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
866 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
867 n = BINFO_N_BASE_BINFOS (t);
868 for (i = 0; i < n; i++)
869 CHECK_NO_VAR (BINFO_BASE_BINFO (t, i));
870 return false;
871 }
872
873 /* Check presence of pointers to decls in fields of a CONSTRUCTOR T. */
874
875 static bool
876 mentions_vars_p_constructor (tree t)
877 {
878 unsigned HOST_WIDE_INT idx;
879 constructor_elt *ce;
880
881 if (mentions_vars_p_typed (t))
882 return true;
883
884 for (idx = 0; vec_safe_iterate (CONSTRUCTOR_ELTS (t), idx, &ce); idx++)
885 {
886 CHECK_NO_VAR (ce->index);
887 CHECK_VAR (ce->value);
888 }
889 return false;
890 }
891
892 /* Check presence of pointers to decls in fields of an expression tree T. */
893
894 static bool
895 mentions_vars_p_expr (tree t)
896 {
897 int i;
898 if (mentions_vars_p_typed (t))
899 return true;
900 for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i)
901 CHECK_VAR (TREE_OPERAND (t, i));
902 return false;
903 }
904
905 /* Check presence of pointers to decls that needs later fixup in T. */
906
907 static bool
908 mentions_vars_p (tree t)
909 {
910 switch (TREE_CODE (t))
911 {
912 case IDENTIFIER_NODE:
913 break;
914
915 case TREE_LIST:
916 CHECK_VAR (TREE_VALUE (t));
917 CHECK_VAR (TREE_PURPOSE (t));
918 CHECK_NO_VAR (TREE_CHAIN (t));
919 break;
920
921 case FIELD_DECL:
922 return mentions_vars_p_field_decl (t);
923 break;
924
925 case LABEL_DECL:
926 case CONST_DECL:
927 case PARM_DECL:
928 case RESULT_DECL:
929 case IMPORTED_DECL:
930 case NAMESPACE_DECL:
931 return mentions_vars_p_decl_common (t);
932 break;
933
934 case VAR_DECL:
935 return mentions_vars_p_decl_with_vis (t);
936 break;
937
938 case TYPE_DECL:
939 return mentions_vars_p_decl_non_common (t);
940 break;
941
942 case FUNCTION_DECL:
943 return mentions_vars_p_function (t);
944 break;
945
946 case TREE_BINFO:
947 return mentions_vars_p_binfo (t);
948 break;
949
950 case PLACEHOLDER_EXPR:
951 return mentions_vars_p_common (t);
952 break;
953
954 case BLOCK:
955 case TRANSLATION_UNIT_DECL:
956 case OPTIMIZATION_NODE:
957 case TARGET_OPTION_NODE:
958 break;
959
960 case CONSTRUCTOR:
961 return mentions_vars_p_constructor (t);
962 break;
963
964 default:
965 if (TYPE_P (t))
966 {
967 if (mentions_vars_p_type (t))
968 return true;
969 }
970 else if (EXPR_P (t))
971 {
972 if (mentions_vars_p_expr (t))
973 return true;
974 }
975 else if (CONSTANT_CLASS_P (t))
976 CHECK_NO_VAR (TREE_TYPE (t));
977 else
978 gcc_unreachable ();
979 }
980 return false;
981 }
982
983
984 /* Return the resolution for the decl with index INDEX from DATA_IN. */
985
986 static enum ld_plugin_symbol_resolution
987 get_resolution (struct data_in *data_in, unsigned index)
988 {
989 if (data_in->globals_resolution.exists ())
990 {
991 ld_plugin_symbol_resolution_t ret;
992 /* We can have references to not emitted functions in
993 DECL_FUNCTION_PERSONALITY at least. So we can and have
994 to indeed return LDPR_UNKNOWN in some cases. */
995 if (data_in->globals_resolution.length () <= index)
996 return LDPR_UNKNOWN;
997 ret = data_in->globals_resolution[index];
998 return ret;
999 }
1000 else
1001 /* Delay resolution finding until decl merging. */
1002 return LDPR_UNKNOWN;
1003 }
1004
1005 /* We need to record resolutions until symbol table is read. */
1006 static void
1007 register_resolution (struct lto_file_decl_data *file_data, tree decl,
1008 enum ld_plugin_symbol_resolution resolution)
1009 {
1010 if (resolution == LDPR_UNKNOWN)
1011 return;
1012 if (!file_data->resolution_map)
1013 file_data->resolution_map = pointer_map_create ();
1014 *pointer_map_insert (file_data->resolution_map, decl) = (void *)(size_t)resolution;
1015 }
1016
1017 /* Register DECL with the global symbol table and change its
1018 name if necessary to avoid name clashes for static globals across
1019 different files. */
1020
1021 static void
1022 lto_register_var_decl_in_symtab (struct data_in *data_in, tree decl,
1023 unsigned ix)
1024 {
1025 tree context;
1026
1027 /* Variable has file scope, not local. */
1028 if (!TREE_PUBLIC (decl)
1029 && !((context = decl_function_context (decl))
1030 && auto_var_in_fn_p (decl, context)))
1031 rest_of_decl_compilation (decl, 1, 0);
1032
1033 /* If this variable has already been declared, queue the
1034 declaration for merging. */
1035 if (TREE_PUBLIC (decl))
1036 register_resolution (data_in->file_data,
1037 decl, get_resolution (data_in, ix));
1038 }
1039
1040
1041 /* Register DECL with the global symbol table and change its
1042 name if necessary to avoid name clashes for static globals across
1043 different files. DATA_IN contains descriptors and tables for the
1044 file being read. */
1045
1046 static void
1047 lto_register_function_decl_in_symtab (struct data_in *data_in, tree decl,
1048 unsigned ix)
1049 {
1050 /* If this variable has already been declared, queue the
1051 declaration for merging. */
1052 if (TREE_PUBLIC (decl) && !DECL_ABSTRACT (decl))
1053 register_resolution (data_in->file_data,
1054 decl, get_resolution (data_in, ix));
1055 }
1056
1057
1058 /* For the type T re-materialize it in the type variant list and
1059 the pointer/reference-to chains. */
1060
1061 static void
1062 lto_fixup_prevailing_type (tree t)
1063 {
1064 /* The following re-creates proper variant lists while fixing up
1065 the variant leaders. We do not stream TYPE_NEXT_VARIANT so the
1066 variant list state before fixup is broken. */
1067
1068 /* If we are not our own variant leader link us into our new leaders
1069 variant list. */
1070 if (TYPE_MAIN_VARIANT (t) != t)
1071 {
1072 tree mv = TYPE_MAIN_VARIANT (t);
1073 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (mv);
1074 TYPE_NEXT_VARIANT (mv) = t;
1075 }
1076
1077 /* The following reconstructs the pointer chains
1078 of the new pointed-to type if we are a main variant. We do
1079 not stream those so they are broken before fixup. */
1080 if (TREE_CODE (t) == POINTER_TYPE
1081 && TYPE_MAIN_VARIANT (t) == t)
1082 {
1083 TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (TREE_TYPE (t));
1084 TYPE_POINTER_TO (TREE_TYPE (t)) = t;
1085 }
1086 else if (TREE_CODE (t) == REFERENCE_TYPE
1087 && TYPE_MAIN_VARIANT (t) == t)
1088 {
1089 TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (TREE_TYPE (t));
1090 TYPE_REFERENCE_TO (TREE_TYPE (t)) = t;
1091 }
1092 }
1093
1094
1095 /* We keep prevailing tree SCCs in a hashtable with manual collision
1096 handling (in case all hashes compare the same) and keep the colliding
1097 entries in the tree_scc->next chain. */
1098
1099 struct tree_scc
1100 {
1101 tree_scc *next;
1102 /* Hash of the whole SCC. */
1103 hashval_t hash;
1104 /* Number of trees in the SCC. */
1105 unsigned len;
1106 /* Number of possible entries into the SCC (tree nodes [0..entry_len-1]
1107 which share the same individual tree hash). */
1108 unsigned entry_len;
1109 /* The members of the SCC.
1110 We only need to remember the first entry node candidate for prevailing
1111 SCCs (but of course have access to all entries for SCCs we are
1112 processing).
1113 ??? For prevailing SCCs we really only need hash and the first
1114 entry candidate, but that's too awkward to implement. */
1115 tree entries[1];
1116 };
1117
1118 struct tree_scc_hasher : typed_noop_remove <tree_scc>
1119 {
1120 typedef tree_scc value_type;
1121 typedef tree_scc compare_type;
1122 static inline hashval_t hash (const value_type *);
1123 static inline bool equal (const value_type *, const compare_type *);
1124 };
1125
1126 hashval_t
1127 tree_scc_hasher::hash (const value_type *scc)
1128 {
1129 return scc->hash;
1130 }
1131
1132 bool
1133 tree_scc_hasher::equal (const value_type *scc1, const compare_type *scc2)
1134 {
1135 if (scc1->hash != scc2->hash
1136 || scc1->len != scc2->len
1137 || scc1->entry_len != scc2->entry_len)
1138 return false;
1139 return true;
1140 }
1141
1142 static hash_table <tree_scc_hasher> tree_scc_hash;
1143 static struct obstack tree_scc_hash_obstack;
1144
1145 static unsigned long num_merged_types;
1146 static unsigned long num_prevailing_types;
1147 static unsigned long num_type_scc_trees;
1148 static unsigned long total_scc_size;
1149 static unsigned long num_sccs_read;
1150 static unsigned long total_scc_size_merged;
1151 static unsigned long num_sccs_merged;
1152 static unsigned long num_scc_compares;
1153 static unsigned long num_scc_compare_collisions;
1154
1155
1156 /* Compare the two entries T1 and T2 of two SCCs that are possibly equal,
1157 recursing through in-SCC tree edges. Returns true if the SCCs entered
1158 through T1 and T2 are equal and fills in *MAP with the pairs of
1159 SCC entries we visited, starting with (*MAP)[0] = T1 and (*MAP)[1] = T2. */
1160
1161 static bool
1162 compare_tree_sccs_1 (tree t1, tree t2, tree **map)
1163 {
1164 enum tree_code code;
1165
1166 /* Mark already visited nodes. */
1167 TREE_ASM_WRITTEN (t2) = 1;
1168
1169 /* Push the pair onto map. */
1170 (*map)[0] = t1;
1171 (*map)[1] = t2;
1172 *map = *map + 2;
1173
1174 /* Compare value-fields. */
1175 #define compare_values(X) \
1176 do { \
1177 if (X(t1) != X(t2)) \
1178 return false; \
1179 } while (0)
1180
1181 compare_values (TREE_CODE);
1182 code = TREE_CODE (t1);
1183
1184 if (!TYPE_P (t1))
1185 {
1186 compare_values (TREE_SIDE_EFFECTS);
1187 compare_values (TREE_CONSTANT);
1188 compare_values (TREE_READONLY);
1189 compare_values (TREE_PUBLIC);
1190 }
1191 compare_values (TREE_ADDRESSABLE);
1192 compare_values (TREE_THIS_VOLATILE);
1193 if (DECL_P (t1))
1194 compare_values (DECL_UNSIGNED);
1195 else if (TYPE_P (t1))
1196 compare_values (TYPE_UNSIGNED);
1197 if (TYPE_P (t1))
1198 compare_values (TYPE_ARTIFICIAL);
1199 else
1200 compare_values (TREE_NO_WARNING);
1201 compare_values (TREE_NOTHROW);
1202 compare_values (TREE_STATIC);
1203 if (code != TREE_BINFO)
1204 compare_values (TREE_PRIVATE);
1205 compare_values (TREE_PROTECTED);
1206 compare_values (TREE_DEPRECATED);
1207 if (TYPE_P (t1))
1208 {
1209 compare_values (TYPE_SATURATING);
1210 compare_values (TYPE_ADDR_SPACE);
1211 }
1212 else if (code == SSA_NAME)
1213 compare_values (SSA_NAME_IS_DEFAULT_DEF);
1214
1215 if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
1216 {
1217 compare_values (TREE_INT_CST_LOW);
1218 compare_values (TREE_INT_CST_HIGH);
1219 }
1220
1221 if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
1222 {
1223 /* ??? No suitable compare routine available. */
1224 REAL_VALUE_TYPE r1 = TREE_REAL_CST (t1);
1225 REAL_VALUE_TYPE r2 = TREE_REAL_CST (t2);
1226 if (r1.cl != r2.cl
1227 || r1.decimal != r2.decimal
1228 || r1.sign != r2.sign
1229 || r1.signalling != r2.signalling
1230 || r1.canonical != r2.canonical
1231 || r1.uexp != r2.uexp)
1232 return false;
1233 for (unsigned i = 0; i < SIGSZ; ++i)
1234 if (r1.sig[i] != r2.sig[i])
1235 return false;
1236 }
1237
1238 if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
1239 if (!fixed_compare (EQ_EXPR,
1240 TREE_FIXED_CST_PTR (t1), TREE_FIXED_CST_PTR (t2)))
1241 return false;
1242
1243
1244 /* We don't want to compare locations, so there is nothing do compare
1245 for TS_DECL_MINIMAL. */
1246
1247 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1248 {
1249 compare_values (DECL_MODE);
1250 compare_values (DECL_NONLOCAL);
1251 compare_values (DECL_VIRTUAL_P);
1252 compare_values (DECL_IGNORED_P);
1253 compare_values (DECL_ABSTRACT);
1254 compare_values (DECL_ARTIFICIAL);
1255 compare_values (DECL_USER_ALIGN);
1256 compare_values (DECL_PRESERVE_P);
1257 compare_values (DECL_EXTERNAL);
1258 compare_values (DECL_GIMPLE_REG_P);
1259 compare_values (DECL_ALIGN);
1260 if (code == LABEL_DECL)
1261 {
1262 compare_values (EH_LANDING_PAD_NR);
1263 compare_values (LABEL_DECL_UID);
1264 }
1265 else if (code == FIELD_DECL)
1266 {
1267 compare_values (DECL_PACKED);
1268 compare_values (DECL_NONADDRESSABLE_P);
1269 compare_values (DECL_OFFSET_ALIGN);
1270 }
1271 else if (code == VAR_DECL)
1272 {
1273 compare_values (DECL_HAS_DEBUG_EXPR_P);
1274 compare_values (DECL_NONLOCAL_FRAME);
1275 }
1276 if (code == RESULT_DECL
1277 || code == PARM_DECL
1278 || code == VAR_DECL)
1279 {
1280 compare_values (DECL_BY_REFERENCE);
1281 if (code == VAR_DECL
1282 || code == PARM_DECL)
1283 compare_values (DECL_HAS_VALUE_EXPR_P);
1284 }
1285 }
1286
1287 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
1288 compare_values (DECL_REGISTER);
1289
1290 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
1291 {
1292 compare_values (DECL_COMMON);
1293 compare_values (DECL_DLLIMPORT_P);
1294 compare_values (DECL_WEAK);
1295 compare_values (DECL_SEEN_IN_BIND_EXPR_P);
1296 compare_values (DECL_COMDAT);
1297 compare_values (DECL_VISIBILITY);
1298 compare_values (DECL_VISIBILITY_SPECIFIED);
1299 if (code == VAR_DECL)
1300 {
1301 compare_values (DECL_HARD_REGISTER);
1302 /* DECL_IN_TEXT_SECTION is set during final asm output only. */
1303 compare_values (DECL_IN_CONSTANT_POOL);
1304 compare_values (DECL_TLS_MODEL);
1305 }
1306 if (VAR_OR_FUNCTION_DECL_P (t1))
1307 compare_values (DECL_INIT_PRIORITY);
1308 }
1309
1310 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
1311 {
1312 compare_values (DECL_BUILT_IN_CLASS);
1313 compare_values (DECL_STATIC_CONSTRUCTOR);
1314 compare_values (DECL_STATIC_DESTRUCTOR);
1315 compare_values (DECL_UNINLINABLE);
1316 compare_values (DECL_POSSIBLY_INLINED);
1317 compare_values (DECL_IS_NOVOPS);
1318 compare_values (DECL_IS_RETURNS_TWICE);
1319 compare_values (DECL_IS_MALLOC);
1320 compare_values (DECL_IS_OPERATOR_NEW);
1321 compare_values (DECL_DECLARED_INLINE_P);
1322 compare_values (DECL_STATIC_CHAIN);
1323 compare_values (DECL_NO_INLINE_WARNING_P);
1324 compare_values (DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT);
1325 compare_values (DECL_NO_LIMIT_STACK);
1326 compare_values (DECL_DISREGARD_INLINE_LIMITS);
1327 compare_values (DECL_PURE_P);
1328 compare_values (DECL_LOOPING_CONST_OR_PURE_P);
1329 compare_values (DECL_FINAL_P);
1330 compare_values (DECL_CXX_CONSTRUCTOR_P);
1331 compare_values (DECL_CXX_DESTRUCTOR_P);
1332 if (DECL_BUILT_IN_CLASS (t1) != NOT_BUILT_IN)
1333 compare_values (DECL_FUNCTION_CODE);
1334 if (DECL_STATIC_DESTRUCTOR (t1))
1335 compare_values (DECL_FINI_PRIORITY);
1336 }
1337
1338 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
1339 {
1340 compare_values (TYPE_MODE);
1341 compare_values (TYPE_STRING_FLAG);
1342 compare_values (TYPE_NO_FORCE_BLK);
1343 compare_values (TYPE_NEEDS_CONSTRUCTING);
1344 if (RECORD_OR_UNION_TYPE_P (t1))
1345 {
1346 compare_values (TYPE_TRANSPARENT_AGGR);
1347 compare_values (TYPE_FINAL_P);
1348 }
1349 else if (code == ARRAY_TYPE)
1350 compare_values (TYPE_NONALIASED_COMPONENT);
1351 compare_values (TYPE_PACKED);
1352 compare_values (TYPE_RESTRICT);
1353 compare_values (TYPE_USER_ALIGN);
1354 compare_values (TYPE_READONLY);
1355 compare_values (TYPE_PRECISION);
1356 compare_values (TYPE_ALIGN);
1357 compare_values (TYPE_ALIAS_SET);
1358 }
1359
1360 /* We don't want to compare locations, so there is nothing do compare
1361 for TS_EXP. */
1362
1363 /* BLOCKs are function local and we don't merge anything there, so
1364 simply refuse to merge. */
1365 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
1366 return false;
1367
1368 if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
1369 if (strcmp (TRANSLATION_UNIT_LANGUAGE (t1),
1370 TRANSLATION_UNIT_LANGUAGE (t2)) != 0)
1371 return false;
1372
1373 if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
1374 if (memcmp (TREE_TARGET_OPTION (t1), TREE_TARGET_OPTION (t2),
1375 sizeof (struct cl_target_option)) != 0)
1376 return false;
1377
1378 if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
1379 if (memcmp (TREE_OPTIMIZATION (t1), TREE_OPTIMIZATION (t2),
1380 sizeof (struct cl_optimization)) != 0)
1381 return false;
1382
1383 if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1384 if (vec_safe_length (BINFO_BASE_ACCESSES (t1))
1385 != vec_safe_length (BINFO_BASE_ACCESSES (t2)))
1386 return false;
1387
1388 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
1389 compare_values (CONSTRUCTOR_NELTS);
1390
1391 if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
1392 if (IDENTIFIER_LENGTH (t1) != IDENTIFIER_LENGTH (t2)
1393 || memcmp (IDENTIFIER_POINTER (t1), IDENTIFIER_POINTER (t2),
1394 IDENTIFIER_LENGTH (t1)) != 0)
1395 return false;
1396
1397 if (CODE_CONTAINS_STRUCT (code, TS_STRING))
1398 if (TREE_STRING_LENGTH (t1) != TREE_STRING_LENGTH (t2)
1399 || memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
1400 TREE_STRING_LENGTH (t1)) != 0)
1401 return false;
1402
1403 #undef compare_values
1404
1405
1406 /* Compare pointer fields. */
1407
1408 /* Recurse. Search & Replaced from DFS_write_tree_body.
1409 Folding the early checks into the compare_tree_edges recursion
1410 macro makes debugging way quicker as you are able to break on
1411 compare_tree_sccs_1 and simply finish until a call returns false
1412 to spot the SCC members with the difference. */
1413 #define compare_tree_edges(E1, E2) \
1414 do { \
1415 tree t1_ = (E1), t2_ = (E2); \
1416 if (t1_ != t2_ \
1417 && (!t1_ || !t2_ \
1418 || !TREE_VISITED (t2_) \
1419 || (!TREE_ASM_WRITTEN (t2_) \
1420 && !compare_tree_sccs_1 (t1_, t2_, map)))) \
1421 return false; \
1422 /* Only non-NULL trees outside of the SCC may compare equal. */ \
1423 gcc_checking_assert (t1_ != t2_ || (!t2_ || !TREE_VISITED (t2_))); \
1424 } while (0)
1425
1426 if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
1427 {
1428 if (code != IDENTIFIER_NODE)
1429 compare_tree_edges (TREE_TYPE (t1), TREE_TYPE (t2));
1430 }
1431
1432 if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
1433 {
1434 unsigned i;
1435 /* Note that the number of elements for EXPR has already been emitted
1436 in EXPR's header (see streamer_write_tree_header). */
1437 for (i = 0; i < VECTOR_CST_NELTS (t1); ++i)
1438 compare_tree_edges (VECTOR_CST_ELT (t1, i), VECTOR_CST_ELT (t2, i));
1439 }
1440
1441 if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
1442 {
1443 compare_tree_edges (TREE_REALPART (t1), TREE_REALPART (t2));
1444 compare_tree_edges (TREE_IMAGPART (t1), TREE_IMAGPART (t2));
1445 }
1446
1447 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
1448 {
1449 compare_tree_edges (DECL_NAME (t1), DECL_NAME (t2));
1450 /* ??? Global decls from different TUs have non-matching
1451 TRANSLATION_UNIT_DECLs. Only consider a small set of
1452 decls equivalent, we should not end up merging others. */
1453 if ((code == TYPE_DECL
1454 || code == NAMESPACE_DECL
1455 || code == IMPORTED_DECL
1456 || code == CONST_DECL
1457 || (VAR_OR_FUNCTION_DECL_P (t1)
1458 && (TREE_PUBLIC (t1) || DECL_EXTERNAL (t1))))
1459 && DECL_FILE_SCOPE_P (t1) && DECL_FILE_SCOPE_P (t2))
1460 ;
1461 else
1462 compare_tree_edges (DECL_CONTEXT (t1), DECL_CONTEXT (t2));
1463 }
1464
1465 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1466 {
1467 compare_tree_edges (DECL_SIZE (t1), DECL_SIZE (t2));
1468 compare_tree_edges (DECL_SIZE_UNIT (t1), DECL_SIZE_UNIT (t2));
1469 compare_tree_edges (DECL_ATTRIBUTES (t1), DECL_ATTRIBUTES (t2));
1470 if ((code == VAR_DECL
1471 || code == PARM_DECL)
1472 && DECL_HAS_VALUE_EXPR_P (t1))
1473 compare_tree_edges (DECL_VALUE_EXPR (t1), DECL_VALUE_EXPR (t2));
1474 if (code == VAR_DECL
1475 && DECL_HAS_DEBUG_EXPR_P (t1))
1476 compare_tree_edges (DECL_DEBUG_EXPR (t1), DECL_DEBUG_EXPR (t2));
1477 /* LTO specific edges. */
1478 if (code != FUNCTION_DECL
1479 && code != TRANSLATION_UNIT_DECL)
1480 compare_tree_edges (DECL_INITIAL (t1), DECL_INITIAL (t2));
1481 }
1482
1483 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
1484 {
1485 if (code == FUNCTION_DECL)
1486 {
1487 tree a1, a2;
1488 for (a1 = DECL_ARGUMENTS (t1), a2 = DECL_ARGUMENTS (t2);
1489 a1 || a2;
1490 a1 = TREE_CHAIN (a1), a2 = TREE_CHAIN (a2))
1491 compare_tree_edges (a1, a2);
1492 compare_tree_edges (DECL_RESULT (t1), DECL_RESULT (t2));
1493 }
1494 else if (code == TYPE_DECL)
1495 compare_tree_edges (DECL_ORIGINAL_TYPE (t1), DECL_ORIGINAL_TYPE (t2));
1496 compare_tree_edges (DECL_VINDEX (t1), DECL_VINDEX (t2));
1497 }
1498
1499 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
1500 {
1501 /* Make sure we don't inadvertently set the assembler name. */
1502 if (DECL_ASSEMBLER_NAME_SET_P (t1))
1503 compare_tree_edges (DECL_ASSEMBLER_NAME (t1),
1504 DECL_ASSEMBLER_NAME (t2));
1505 compare_tree_edges (DECL_SECTION_NAME (t1), DECL_SECTION_NAME (t2));
1506 compare_tree_edges (DECL_COMDAT_GROUP (t1), DECL_COMDAT_GROUP (t2));
1507 }
1508
1509 if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
1510 {
1511 compare_tree_edges (DECL_FIELD_OFFSET (t1), DECL_FIELD_OFFSET (t2));
1512 compare_tree_edges (DECL_BIT_FIELD_TYPE (t1), DECL_BIT_FIELD_TYPE (t2));
1513 compare_tree_edges (DECL_BIT_FIELD_REPRESENTATIVE (t1),
1514 DECL_BIT_FIELD_REPRESENTATIVE (t2));
1515 compare_tree_edges (DECL_FIELD_BIT_OFFSET (t1),
1516 DECL_FIELD_BIT_OFFSET (t2));
1517 compare_tree_edges (DECL_FCONTEXT (t1), DECL_FCONTEXT (t2));
1518 }
1519
1520 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
1521 {
1522 compare_tree_edges (DECL_FUNCTION_PERSONALITY (t1),
1523 DECL_FUNCTION_PERSONALITY (t2));
1524 compare_tree_edges (DECL_FUNCTION_SPECIFIC_TARGET (t1),
1525 DECL_FUNCTION_SPECIFIC_TARGET (t2));
1526 compare_tree_edges (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t1),
1527 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t2));
1528 }
1529
1530 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
1531 {
1532 compare_tree_edges (TYPE_SIZE (t1), TYPE_SIZE (t2));
1533 compare_tree_edges (TYPE_SIZE_UNIT (t1), TYPE_SIZE_UNIT (t2));
1534 compare_tree_edges (TYPE_ATTRIBUTES (t1), TYPE_ATTRIBUTES (t2));
1535 compare_tree_edges (TYPE_NAME (t1), TYPE_NAME (t2));
1536 /* Do not compare TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
1537 reconstructed during fixup. */
1538 /* Do not compare TYPE_NEXT_VARIANT, we reconstruct the variant lists
1539 during fixup. */
1540 compare_tree_edges (TYPE_MAIN_VARIANT (t1), TYPE_MAIN_VARIANT (t2));
1541 /* ??? Global types from different TUs have non-matching
1542 TRANSLATION_UNIT_DECLs. Still merge them if they are otherwise
1543 equal. */
1544 if (TYPE_FILE_SCOPE_P (t1) && TYPE_FILE_SCOPE_P (t2))
1545 ;
1546 else
1547 compare_tree_edges (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2));
1548 /* TYPE_CANONICAL is re-computed during type merging, so do not
1549 compare it here. */
1550 compare_tree_edges (TYPE_STUB_DECL (t1), TYPE_STUB_DECL (t2));
1551 }
1552
1553 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
1554 {
1555 if (code == ENUMERAL_TYPE)
1556 compare_tree_edges (TYPE_VALUES (t1), TYPE_VALUES (t2));
1557 else if (code == ARRAY_TYPE)
1558 compare_tree_edges (TYPE_DOMAIN (t1), TYPE_DOMAIN (t2));
1559 else if (RECORD_OR_UNION_TYPE_P (t1))
1560 {
1561 tree f1, f2;
1562 for (f1 = TYPE_FIELDS (t1), f2 = TYPE_FIELDS (t2);
1563 f1 || f2;
1564 f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2))
1565 compare_tree_edges (f1, f2);
1566 compare_tree_edges (TYPE_BINFO (t1), TYPE_BINFO (t2));
1567 }
1568 else if (code == FUNCTION_TYPE
1569 || code == METHOD_TYPE)
1570 compare_tree_edges (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2));
1571 if (!POINTER_TYPE_P (t1))
1572 compare_tree_edges (TYPE_MINVAL (t1), TYPE_MINVAL (t2));
1573 compare_tree_edges (TYPE_MAXVAL (t1), TYPE_MAXVAL (t2));
1574 }
1575
1576 if (CODE_CONTAINS_STRUCT (code, TS_LIST))
1577 {
1578 compare_tree_edges (TREE_PURPOSE (t1), TREE_PURPOSE (t2));
1579 compare_tree_edges (TREE_VALUE (t1), TREE_VALUE (t2));
1580 compare_tree_edges (TREE_CHAIN (t1), TREE_CHAIN (t2));
1581 }
1582
1583 if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1584 for (int i = 0; i < TREE_VEC_LENGTH (t1); i++)
1585 compare_tree_edges (TREE_VEC_ELT (t1, i), TREE_VEC_ELT (t2, i));
1586
1587 if (CODE_CONTAINS_STRUCT (code, TS_EXP))
1588 {
1589 for (int i = 0; i < TREE_OPERAND_LENGTH (t1); i++)
1590 compare_tree_edges (TREE_OPERAND (t1, i),
1591 TREE_OPERAND (t2, i));
1592
1593 /* BLOCKs are function local and we don't merge anything there. */
1594 if (TREE_BLOCK (t1) || TREE_BLOCK (t2))
1595 return false;
1596 }
1597
1598 if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1599 {
1600 unsigned i;
1601 tree t;
1602 /* Lengths have already been compared above. */
1603 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (t1), i, t)
1604 compare_tree_edges (t, BINFO_BASE_BINFO (t2, i));
1605 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (t1), i, t)
1606 compare_tree_edges (t, BINFO_BASE_ACCESS (t2, i));
1607 compare_tree_edges (BINFO_OFFSET (t1), BINFO_OFFSET (t2));
1608 compare_tree_edges (BINFO_VTABLE (t1), BINFO_VTABLE (t2));
1609 compare_tree_edges (BINFO_VPTR_FIELD (t1), BINFO_VPTR_FIELD (t2));
1610 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
1611 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
1612 }
1613
1614 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
1615 {
1616 unsigned i;
1617 tree index, value;
1618 /* Lengths have already been compared above. */
1619 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1), i, index, value)
1620 {
1621 compare_tree_edges (index, CONSTRUCTOR_ELT (t2, i)->index);
1622 compare_tree_edges (value, CONSTRUCTOR_ELT (t2, i)->value);
1623 }
1624 }
1625
1626 #undef compare_tree_edges
1627
1628 return true;
1629 }
1630
1631 /* Compare the tree scc SCC to the prevailing candidate PSCC, filling
1632 out MAP if they are equal. */
1633
1634 static bool
1635 compare_tree_sccs (tree_scc *pscc, tree_scc *scc,
1636 tree *map)
1637 {
1638 /* Assume SCC entry hashes are sorted after their cardinality. Which
1639 means we can simply take the first n-tuple of equal hashes
1640 (which is recorded as entry_len) and do n SCC entry candidate
1641 comparisons. */
1642 for (unsigned i = 0; i < pscc->entry_len; ++i)
1643 {
1644 tree *mapp = map;
1645 num_scc_compare_collisions++;
1646 if (compare_tree_sccs_1 (pscc->entries[0], scc->entries[i], &mapp))
1647 {
1648 /* Equal - no need to reset TREE_VISITED or TREE_ASM_WRITTEN
1649 on the scc as all trees will be freed. */
1650 return true;
1651 }
1652 /* Reset TREE_ASM_WRITTEN on scc for the next compare or in case
1653 the SCC prevails. */
1654 for (unsigned j = 0; j < scc->len; ++j)
1655 TREE_ASM_WRITTEN (scc->entries[j]) = 0;
1656 }
1657
1658 return false;
1659 }
1660
1661 /* QSort sort function to sort a map of two pointers after the 2nd
1662 pointer. */
1663
1664 static int
1665 cmp_tree (const void *p1_, const void *p2_)
1666 {
1667 tree *p1 = (tree *)(const_cast<void *>(p1_));
1668 tree *p2 = (tree *)(const_cast<void *>(p2_));
1669 if (p1[1] == p2[1])
1670 return 0;
1671 return ((uintptr_t)p1[1] < (uintptr_t)p2[1]) ? -1 : 1;
1672 }
1673
1674 /* Try to unify the SCC with nodes FROM to FROM + LEN in CACHE and
1675 hash value SCC_HASH with an already recorded SCC. Return true if
1676 that was successful, otherwise return false. */
1677
1678 static bool
1679 unify_scc (struct streamer_tree_cache_d *cache, unsigned from,
1680 unsigned len, unsigned scc_entry_len, hashval_t scc_hash)
1681 {
1682 bool unified_p = false;
1683 tree_scc *scc
1684 = (tree_scc *) alloca (sizeof (tree_scc) + (len - 1) * sizeof (tree));
1685 scc->next = NULL;
1686 scc->hash = scc_hash;
1687 scc->len = len;
1688 scc->entry_len = scc_entry_len;
1689 for (unsigned i = 0; i < len; ++i)
1690 {
1691 tree t = streamer_tree_cache_get_tree (cache, from + i);
1692 scc->entries[i] = t;
1693 /* Do not merge SCCs with local entities inside them. Also do
1694 not merge TRANSLATION_UNIT_DECLs. */
1695 if (TREE_CODE (t) == TRANSLATION_UNIT_DECL
1696 || (VAR_OR_FUNCTION_DECL_P (t)
1697 && !(TREE_PUBLIC (t) || DECL_EXTERNAL (t)))
1698 || TREE_CODE (t) == LABEL_DECL)
1699 {
1700 /* Avoid doing any work for these cases and do not worry to
1701 record the SCCs for further merging. */
1702 return false;
1703 }
1704 }
1705
1706 /* Look for the list of candidate SCCs to compare against. */
1707 tree_scc **slot;
1708 slot = tree_scc_hash.find_slot_with_hash (scc, scc_hash, INSERT);
1709 if (*slot)
1710 {
1711 /* Try unifying against each candidate. */
1712 num_scc_compares++;
1713
1714 /* Set TREE_VISITED on the scc so we can easily identify tree nodes
1715 outside of the scc when following tree edges. Make sure
1716 that TREE_ASM_WRITTEN is unset so we can use it as 2nd bit
1717 to track whether we visited the SCC member during the compare.
1718 We cannot use TREE_VISITED on the pscc members as the extended
1719 scc and pscc can overlap. */
1720 for (unsigned i = 0; i < scc->len; ++i)
1721 {
1722 TREE_VISITED (scc->entries[i]) = 1;
1723 gcc_checking_assert (!TREE_ASM_WRITTEN (scc->entries[i]));
1724 }
1725
1726 tree *map = XALLOCAVEC (tree, 2 * len);
1727 for (tree_scc *pscc = *slot; pscc; pscc = pscc->next)
1728 {
1729 if (!compare_tree_sccs (pscc, scc, map))
1730 continue;
1731
1732 /* Found an equal SCC. */
1733 unified_p = true;
1734 num_scc_compare_collisions--;
1735 num_sccs_merged++;
1736 total_scc_size_merged += len;
1737
1738 #ifdef ENABLE_CHECKING
1739 for (unsigned i = 0; i < len; ++i)
1740 {
1741 tree t = map[2*i+1];
1742 enum tree_code code = TREE_CODE (t);
1743 /* IDENTIFIER_NODEs should be singletons and are merged by the
1744 streamer. The others should be singletons, too, and we
1745 should not merge them in any way. */
1746 gcc_assert (code != TRANSLATION_UNIT_DECL
1747 && code != IDENTIFIER_NODE
1748 && !streamer_handle_as_builtin_p (t));
1749 }
1750 #endif
1751
1752 /* Fixup the streamer cache with the prevailing nodes according
1753 to the tree node mapping computed by compare_tree_sccs. */
1754 if (len == 1)
1755 streamer_tree_cache_replace_tree (cache, pscc->entries[0], from);
1756 else
1757 {
1758 tree *map2 = XALLOCAVEC (tree, 2 * len);
1759 for (unsigned i = 0; i < len; ++i)
1760 {
1761 map2[i*2] = (tree)(uintptr_t)(from + i);
1762 map2[i*2+1] = scc->entries[i];
1763 }
1764 qsort (map2, len, 2 * sizeof (tree), cmp_tree);
1765 qsort (map, len, 2 * sizeof (tree), cmp_tree);
1766 for (unsigned i = 0; i < len; ++i)
1767 streamer_tree_cache_replace_tree (cache, map[2*i],
1768 (uintptr_t)map2[2*i]);
1769 }
1770
1771 /* Free the tree nodes from the read SCC. */
1772 for (unsigned i = 0; i < len; ++i)
1773 {
1774 if (TYPE_P (scc->entries[i]))
1775 num_merged_types++;
1776 ggc_free (scc->entries[i]);
1777 }
1778
1779 break;
1780 }
1781
1782 /* Reset TREE_VISITED if we didn't unify the SCC with another. */
1783 if (!unified_p)
1784 for (unsigned i = 0; i < scc->len; ++i)
1785 TREE_VISITED (scc->entries[i]) = 0;
1786 }
1787
1788 /* If we didn't unify it to any candidate duplicate the relevant
1789 pieces to permanent storage and link it into the chain. */
1790 if (!unified_p)
1791 {
1792 tree_scc *pscc
1793 = XOBNEWVAR (&tree_scc_hash_obstack, tree_scc, sizeof (tree_scc));
1794 memcpy (pscc, scc, sizeof (tree_scc));
1795 pscc->next = (*slot);
1796 *slot = pscc;
1797 }
1798 return unified_p;
1799 }
1800
1801
1802 /* Read all the symbols from buffer DATA, using descriptors in DECL_DATA.
1803 RESOLUTIONS is the set of symbols picked by the linker (read from the
1804 resolution file when the linker plugin is being used). */
1805
1806 static void
1807 lto_read_decls (struct lto_file_decl_data *decl_data, const void *data,
1808 vec<ld_plugin_symbol_resolution_t> resolutions)
1809 {
1810 const struct lto_decl_header *header = (const struct lto_decl_header *) data;
1811 const int decl_offset = sizeof (struct lto_decl_header);
1812 const int main_offset = decl_offset + header->decl_state_size;
1813 const int string_offset = main_offset + header->main_size;
1814 struct lto_input_block ib_main;
1815 struct data_in *data_in;
1816 unsigned int i;
1817 const uint32_t *data_ptr, *data_end;
1818 uint32_t num_decl_states;
1819
1820 LTO_INIT_INPUT_BLOCK (ib_main, (const char *) data + main_offset, 0,
1821 header->main_size);
1822
1823 data_in = lto_data_in_create (decl_data, (const char *) data + string_offset,
1824 header->string_size, resolutions);
1825
1826 /* We do not uniquify the pre-loaded cache entries, those are middle-end
1827 internal types that should not be merged. */
1828
1829 /* Read the global declarations and types. */
1830 while (ib_main.p < ib_main.len)
1831 {
1832 tree t;
1833 unsigned from = data_in->reader_cache->nodes.length ();
1834 /* Read and uniquify SCCs as in the input stream. */
1835 enum LTO_tags tag = streamer_read_record_start (&ib_main);
1836 if (tag == LTO_tree_scc)
1837 {
1838 unsigned len_;
1839 unsigned scc_entry_len;
1840 hashval_t scc_hash = lto_input_scc (&ib_main, data_in, &len_,
1841 &scc_entry_len);
1842 unsigned len = data_in->reader_cache->nodes.length () - from;
1843 gcc_assert (len == len_);
1844
1845 total_scc_size += len;
1846 num_sccs_read++;
1847
1848 /* We have the special case of size-1 SCCs that are pre-merged
1849 by means of identifier and string sharing for example.
1850 ??? Maybe we should avoid streaming those as SCCs. */
1851 tree first = streamer_tree_cache_get_tree (data_in->reader_cache,
1852 from);
1853 if (len == 1
1854 && (TREE_CODE (first) == IDENTIFIER_NODE
1855 || TREE_CODE (first) == INTEGER_CST
1856 || TREE_CODE (first) == TRANSLATION_UNIT_DECL
1857 || streamer_handle_as_builtin_p (first)))
1858 continue;
1859
1860 /* Try to unify the SCC with already existing ones. */
1861 if (!flag_ltrans
1862 && unify_scc (data_in->reader_cache, from,
1863 len, scc_entry_len, scc_hash))
1864 continue;
1865
1866 /* Do remaining fixup tasks for prevailing nodes. */
1867 bool seen_type = false;
1868 for (unsigned i = 0; i < len; ++i)
1869 {
1870 tree t = streamer_tree_cache_get_tree (data_in->reader_cache,
1871 from + i);
1872 /* Reconstruct the type variant and pointer-to/reference-to
1873 chains. */
1874 if (TYPE_P (t))
1875 {
1876 seen_type = true;
1877 num_prevailing_types++;
1878 lto_fixup_prevailing_type (t);
1879 }
1880 /* Compute the canonical type of all types.
1881 ??? Should be able to assert that !TYPE_CANONICAL. */
1882 if (TYPE_P (t) && !TYPE_CANONICAL (t))
1883 gimple_register_canonical_type (t);
1884 /* Link shared INTEGER_CSTs into TYPE_CACHED_VALUEs of its
1885 type which is also member of this SCC. */
1886 if (TREE_CODE (t) == INTEGER_CST
1887 && !TREE_OVERFLOW (t))
1888 cache_integer_cst (t);
1889 /* Register TYPE_DECLs with the debuginfo machinery. */
1890 if (!flag_wpa
1891 && TREE_CODE (t) == TYPE_DECL)
1892 debug_hooks->type_decl (t, !DECL_FILE_SCOPE_P (t));
1893 if (!flag_ltrans)
1894 {
1895 /* Register variables and functions with the
1896 symbol table. */
1897 if (TREE_CODE (t) == VAR_DECL)
1898 lto_register_var_decl_in_symtab (data_in, t, from + i);
1899 else if (TREE_CODE (t) == FUNCTION_DECL
1900 && !DECL_BUILT_IN (t))
1901 lto_register_function_decl_in_symtab (data_in, t, from + i);
1902 /* Scan the tree for references to global functions or
1903 variables and record those for later fixup. */
1904 if (mentions_vars_p (t))
1905 vec_safe_push (tree_with_vars, t);
1906 }
1907 }
1908 if (seen_type)
1909 num_type_scc_trees += len;
1910 }
1911 else
1912 {
1913 /* Pickle stray references. */
1914 t = lto_input_tree_1 (&ib_main, data_in, tag, 0);
1915 gcc_assert (t && data_in->reader_cache->nodes.length () == from);
1916 }
1917 }
1918
1919 /* Read in lto_in_decl_state objects. */
1920 data_ptr = (const uint32_t *) ((const char*) data + decl_offset);
1921 data_end =
1922 (const uint32_t *) ((const char*) data_ptr + header->decl_state_size);
1923 num_decl_states = *data_ptr++;
1924
1925 gcc_assert (num_decl_states > 0);
1926 decl_data->global_decl_state = lto_new_in_decl_state ();
1927 data_ptr = lto_read_in_decl_state (data_in, data_ptr,
1928 decl_data->global_decl_state);
1929
1930 /* Read in per-function decl states and enter them in hash table. */
1931 decl_data->function_decl_states =
1932 htab_create_ggc (37, lto_hash_in_decl_state, lto_eq_in_decl_state, NULL);
1933
1934 for (i = 1; i < num_decl_states; i++)
1935 {
1936 struct lto_in_decl_state *state = lto_new_in_decl_state ();
1937 void **slot;
1938
1939 data_ptr = lto_read_in_decl_state (data_in, data_ptr, state);
1940 slot = htab_find_slot (decl_data->function_decl_states, state, INSERT);
1941 gcc_assert (*slot == NULL);
1942 *slot = state;
1943 }
1944
1945 if (data_ptr != data_end)
1946 internal_error ("bytecode stream: garbage at the end of symbols section");
1947
1948 /* Set the current decl state to be the global state. */
1949 decl_data->current_decl_state = decl_data->global_decl_state;
1950
1951 lto_data_in_delete (data_in);
1952 }
1953
1954 /* Custom version of strtoll, which is not portable. */
1955
1956 static HOST_WIDEST_INT
1957 lto_parse_hex (const char *p)
1958 {
1959 HOST_WIDEST_INT ret = 0;
1960
1961 for (; *p != '\0'; ++p)
1962 {
1963 char c = *p;
1964 unsigned char part;
1965 ret <<= 4;
1966 if (c >= '0' && c <= '9')
1967 part = c - '0';
1968 else if (c >= 'a' && c <= 'f')
1969 part = c - 'a' + 10;
1970 else if (c >= 'A' && c <= 'F')
1971 part = c - 'A' + 10;
1972 else
1973 internal_error ("could not parse hex number");
1974 ret |= part;
1975 }
1976
1977 return ret;
1978 }
1979
1980 /* Read resolution for file named FILE_NAME. The resolution is read from
1981 RESOLUTION. */
1982
1983 static void
1984 lto_resolution_read (splay_tree file_ids, FILE *resolution, lto_file *file)
1985 {
1986 /* We require that objects in the resolution file are in the same
1987 order as the lto1 command line. */
1988 unsigned int name_len;
1989 char *obj_name;
1990 unsigned int num_symbols;
1991 unsigned int i;
1992 struct lto_file_decl_data *file_data;
1993 splay_tree_node nd = NULL;
1994
1995 if (!resolution)
1996 return;
1997
1998 name_len = strlen (file->filename);
1999 obj_name = XNEWVEC (char, name_len + 1);
2000 fscanf (resolution, " "); /* Read white space. */
2001
2002 fread (obj_name, sizeof (char), name_len, resolution);
2003 obj_name[name_len] = '\0';
2004 if (filename_cmp (obj_name, file->filename) != 0)
2005 internal_error ("unexpected file name %s in linker resolution file. "
2006 "Expected %s", obj_name, file->filename);
2007 if (file->offset != 0)
2008 {
2009 int t;
2010 char offset_p[17];
2011 HOST_WIDEST_INT offset;
2012 t = fscanf (resolution, "@0x%16s", offset_p);
2013 if (t != 1)
2014 internal_error ("could not parse file offset");
2015 offset = lto_parse_hex (offset_p);
2016 if (offset != file->offset)
2017 internal_error ("unexpected offset");
2018 }
2019
2020 free (obj_name);
2021
2022 fscanf (resolution, "%u", &num_symbols);
2023
2024 for (i = 0; i < num_symbols; i++)
2025 {
2026 int t;
2027 unsigned index;
2028 unsigned HOST_WIDE_INT id;
2029 char r_str[27];
2030 enum ld_plugin_symbol_resolution r = (enum ld_plugin_symbol_resolution) 0;
2031 unsigned int j;
2032 unsigned int lto_resolution_str_len =
2033 sizeof (lto_resolution_str) / sizeof (char *);
2034 res_pair rp;
2035
2036 t = fscanf (resolution, "%u " HOST_WIDE_INT_PRINT_HEX_PURE " %26s %*[^\n]\n",
2037 &index, &id, r_str);
2038 if (t != 3)
2039 internal_error ("invalid line in the resolution file");
2040
2041 for (j = 0; j < lto_resolution_str_len; j++)
2042 {
2043 if (strcmp (lto_resolution_str[j], r_str) == 0)
2044 {
2045 r = (enum ld_plugin_symbol_resolution) j;
2046 break;
2047 }
2048 }
2049 if (j == lto_resolution_str_len)
2050 internal_error ("invalid resolution in the resolution file");
2051
2052 if (!(nd && lto_splay_tree_id_equal_p (nd->key, id)))
2053 {
2054 nd = lto_splay_tree_lookup (file_ids, id);
2055 if (nd == NULL)
2056 internal_error ("resolution sub id %wx not in object file", id);
2057 }
2058
2059 file_data = (struct lto_file_decl_data *)nd->value;
2060 /* The indexes are very sparse. To save memory save them in a compact
2061 format that is only unpacked later when the subfile is processed. */
2062 rp.res = r;
2063 rp.index = index;
2064 file_data->respairs.safe_push (rp);
2065 if (file_data->max_index < index)
2066 file_data->max_index = index;
2067 }
2068 }
2069
2070 /* List of file_decl_datas */
2071 struct file_data_list
2072 {
2073 struct lto_file_decl_data *first, *last;
2074 };
2075
2076 /* Is the name for a id'ed LTO section? */
2077
2078 static int
2079 lto_section_with_id (const char *name, unsigned HOST_WIDE_INT *id)
2080 {
2081 const char *s;
2082
2083 if (strncmp (name, LTO_SECTION_NAME_PREFIX, strlen (LTO_SECTION_NAME_PREFIX)))
2084 return 0;
2085 s = strrchr (name, '.');
2086 return s && sscanf (s, "." HOST_WIDE_INT_PRINT_HEX_PURE, id) == 1;
2087 }
2088
2089 /* Create file_data of each sub file id */
2090
2091 static int
2092 create_subid_section_table (struct lto_section_slot *ls, splay_tree file_ids,
2093 struct file_data_list *list)
2094 {
2095 struct lto_section_slot s_slot, *new_slot;
2096 unsigned HOST_WIDE_INT id;
2097 splay_tree_node nd;
2098 void **hash_slot;
2099 char *new_name;
2100 struct lto_file_decl_data *file_data;
2101
2102 if (!lto_section_with_id (ls->name, &id))
2103 return 1;
2104
2105 /* Find hash table of sub module id */
2106 nd = lto_splay_tree_lookup (file_ids, id);
2107 if (nd != NULL)
2108 {
2109 file_data = (struct lto_file_decl_data *)nd->value;
2110 }
2111 else
2112 {
2113 file_data = ggc_alloc_lto_file_decl_data ();
2114 memset(file_data, 0, sizeof (struct lto_file_decl_data));
2115 file_data->id = id;
2116 file_data->section_hash_table = lto_obj_create_section_hash_table ();;
2117 lto_splay_tree_insert (file_ids, id, file_data);
2118
2119 /* Maintain list in linker order */
2120 if (!list->first)
2121 list->first = file_data;
2122 if (list->last)
2123 list->last->next = file_data;
2124 list->last = file_data;
2125 }
2126
2127 /* Copy section into sub module hash table */
2128 new_name = XDUPVEC (char, ls->name, strlen (ls->name) + 1);
2129 s_slot.name = new_name;
2130 hash_slot = htab_find_slot (file_data->section_hash_table, &s_slot, INSERT);
2131 gcc_assert (*hash_slot == NULL);
2132
2133 new_slot = XDUP (struct lto_section_slot, ls);
2134 new_slot->name = new_name;
2135 *hash_slot = new_slot;
2136 return 1;
2137 }
2138
2139 /* Read declarations and other initializations for a FILE_DATA. */
2140
2141 static void
2142 lto_file_finalize (struct lto_file_decl_data *file_data, lto_file *file)
2143 {
2144 const char *data;
2145 size_t len;
2146 vec<ld_plugin_symbol_resolution_t>
2147 resolutions = vNULL;
2148 int i;
2149 res_pair *rp;
2150
2151 /* Create vector for fast access of resolution. We do this lazily
2152 to save memory. */
2153 resolutions.safe_grow_cleared (file_data->max_index + 1);
2154 for (i = 0; file_data->respairs.iterate (i, &rp); i++)
2155 resolutions[rp->index] = rp->res;
2156 file_data->respairs.release ();
2157
2158 file_data->renaming_hash_table = lto_create_renaming_table ();
2159 file_data->file_name = file->filename;
2160 data = lto_get_section_data (file_data, LTO_section_decls, NULL, &len);
2161 if (data == NULL)
2162 {
2163 internal_error ("cannot read LTO decls from %s", file_data->file_name);
2164 return;
2165 }
2166 /* Frees resolutions */
2167 lto_read_decls (file_data, data, resolutions);
2168 lto_free_section_data (file_data, LTO_section_decls, NULL, data, len);
2169 }
2170
2171 /* Finalize FILE_DATA in FILE and increase COUNT. */
2172
2173 static int
2174 lto_create_files_from_ids (lto_file *file, struct lto_file_decl_data *file_data,
2175 int *count)
2176 {
2177 lto_file_finalize (file_data, file);
2178 if (cgraph_dump_file)
2179 fprintf (cgraph_dump_file, "Creating file %s with sub id " HOST_WIDE_INT_PRINT_HEX "\n",
2180 file_data->file_name, file_data->id);
2181 (*count)++;
2182 return 0;
2183 }
2184
2185 /* Generate a TREE representation for all types and external decls
2186 entities in FILE.
2187
2188 Read all of the globals out of the file. Then read the cgraph
2189 and process the .o index into the cgraph nodes so that it can open
2190 the .o file to load the functions and ipa information. */
2191
2192 static struct lto_file_decl_data *
2193 lto_file_read (lto_file *file, FILE *resolution_file, int *count)
2194 {
2195 struct lto_file_decl_data *file_data = NULL;
2196 splay_tree file_ids;
2197 htab_t section_hash_table;
2198 struct lto_section_slot *section;
2199 struct file_data_list file_list;
2200 struct lto_section_list section_list;
2201
2202 memset (&section_list, 0, sizeof (struct lto_section_list));
2203 section_hash_table = lto_obj_build_section_table (file, &section_list);
2204
2205 /* Find all sub modules in the object and put their sections into new hash
2206 tables in a splay tree. */
2207 file_ids = lto_splay_tree_new ();
2208 memset (&file_list, 0, sizeof (struct file_data_list));
2209 for (section = section_list.first; section != NULL; section = section->next)
2210 create_subid_section_table (section, file_ids, &file_list);
2211
2212 /* Add resolutions to file ids */
2213 lto_resolution_read (file_ids, resolution_file, file);
2214
2215 /* Finalize each lto file for each submodule in the merged object */
2216 for (file_data = file_list.first; file_data != NULL; file_data = file_data->next)
2217 lto_create_files_from_ids (file, file_data, count);
2218
2219 splay_tree_delete (file_ids);
2220 htab_delete (section_hash_table);
2221
2222 return file_list.first;
2223 }
2224
2225 #if HAVE_MMAP_FILE && HAVE_SYSCONF && defined _SC_PAGE_SIZE
2226 #define LTO_MMAP_IO 1
2227 #endif
2228
2229 #if LTO_MMAP_IO
2230 /* Page size of machine is used for mmap and munmap calls. */
2231 static size_t page_mask;
2232 #endif
2233
2234 /* Get the section data of length LEN from FILENAME starting at
2235 OFFSET. The data segment must be freed by the caller when the
2236 caller is finished. Returns NULL if all was not well. */
2237
2238 static char *
2239 lto_read_section_data (struct lto_file_decl_data *file_data,
2240 intptr_t offset, size_t len)
2241 {
2242 char *result;
2243 static int fd = -1;
2244 static char *fd_name;
2245 #if LTO_MMAP_IO
2246 intptr_t computed_len;
2247 intptr_t computed_offset;
2248 intptr_t diff;
2249 #endif
2250
2251 /* Keep a single-entry file-descriptor cache. The last file we
2252 touched will get closed at exit.
2253 ??? Eventually we want to add a more sophisticated larger cache
2254 or rather fix function body streaming to not stream them in
2255 practically random order. */
2256 if (fd != -1
2257 && filename_cmp (fd_name, file_data->file_name) != 0)
2258 {
2259 free (fd_name);
2260 close (fd);
2261 fd = -1;
2262 }
2263 if (fd == -1)
2264 {
2265 fd = open (file_data->file_name, O_RDONLY|O_BINARY);
2266 if (fd == -1)
2267 {
2268 fatal_error ("Cannot open %s", file_data->file_name);
2269 return NULL;
2270 }
2271 fd_name = xstrdup (file_data->file_name);
2272 }
2273
2274 #if LTO_MMAP_IO
2275 if (!page_mask)
2276 {
2277 size_t page_size = sysconf (_SC_PAGE_SIZE);
2278 page_mask = ~(page_size - 1);
2279 }
2280
2281 computed_offset = offset & page_mask;
2282 diff = offset - computed_offset;
2283 computed_len = len + diff;
2284
2285 result = (char *) mmap (NULL, computed_len, PROT_READ, MAP_PRIVATE,
2286 fd, computed_offset);
2287 if (result == MAP_FAILED)
2288 {
2289 fatal_error ("Cannot map %s", file_data->file_name);
2290 return NULL;
2291 }
2292
2293 return result + diff;
2294 #else
2295 result = (char *) xmalloc (len);
2296 if (lseek (fd, offset, SEEK_SET) != offset
2297 || read (fd, result, len) != (ssize_t) len)
2298 {
2299 free (result);
2300 fatal_error ("Cannot read %s", file_data->file_name);
2301 result = NULL;
2302 }
2303 #ifdef __MINGW32__
2304 /* Native windows doesn't supports delayed unlink on opened file. So
2305 we close file here again. This produces higher I/O load, but at least
2306 it prevents to have dangling file handles preventing unlink. */
2307 free (fd_name);
2308 fd_name = NULL;
2309 close (fd);
2310 fd = -1;
2311 #endif
2312 return result;
2313 #endif
2314 }
2315
2316
2317 /* Get the section data from FILE_DATA of SECTION_TYPE with NAME.
2318 NAME will be NULL unless the section type is for a function
2319 body. */
2320
2321 static const char *
2322 get_section_data (struct lto_file_decl_data *file_data,
2323 enum lto_section_type section_type,
2324 const char *name,
2325 size_t *len)
2326 {
2327 htab_t section_hash_table = file_data->section_hash_table;
2328 struct lto_section_slot *f_slot;
2329 struct lto_section_slot s_slot;
2330 const char *section_name = lto_get_section_name (section_type, name, file_data);
2331 char *data = NULL;
2332
2333 *len = 0;
2334 s_slot.name = section_name;
2335 f_slot = (struct lto_section_slot *) htab_find (section_hash_table, &s_slot);
2336 if (f_slot)
2337 {
2338 data = lto_read_section_data (file_data, f_slot->start, f_slot->len);
2339 *len = f_slot->len;
2340 }
2341
2342 free (CONST_CAST (char *, section_name));
2343 return data;
2344 }
2345
2346
2347 /* Free the section data from FILE_DATA of SECTION_TYPE with NAME that
2348 starts at OFFSET and has LEN bytes. */
2349
2350 static void
2351 free_section_data (struct lto_file_decl_data *file_data ATTRIBUTE_UNUSED,
2352 enum lto_section_type section_type ATTRIBUTE_UNUSED,
2353 const char *name ATTRIBUTE_UNUSED,
2354 const char *offset, size_t len ATTRIBUTE_UNUSED)
2355 {
2356 #if LTO_MMAP_IO
2357 intptr_t computed_len;
2358 intptr_t computed_offset;
2359 intptr_t diff;
2360 #endif
2361
2362 #if LTO_MMAP_IO
2363 computed_offset = ((intptr_t) offset) & page_mask;
2364 diff = (intptr_t) offset - computed_offset;
2365 computed_len = len + diff;
2366
2367 munmap ((caddr_t) computed_offset, computed_len);
2368 #else
2369 free (CONST_CAST(char *, offset));
2370 #endif
2371 }
2372
2373 static lto_file *current_lto_file;
2374
2375 /* Helper for qsort; compare partitions and return one with smaller size.
2376 We sort from greatest to smallest so parallel build doesn't stale on the
2377 longest compilation being executed too late. */
2378
2379 static int
2380 cmp_partitions_size (const void *a, const void *b)
2381 {
2382 const struct ltrans_partition_def *pa
2383 = *(struct ltrans_partition_def *const *)a;
2384 const struct ltrans_partition_def *pb
2385 = *(struct ltrans_partition_def *const *)b;
2386 return pb->insns - pa->insns;
2387 }
2388
2389 /* Helper for qsort; compare partitions and return one with smaller order. */
2390
2391 static int
2392 cmp_partitions_order (const void *a, const void *b)
2393 {
2394 const struct ltrans_partition_def *pa
2395 = *(struct ltrans_partition_def *const *)a;
2396 const struct ltrans_partition_def *pb
2397 = *(struct ltrans_partition_def *const *)b;
2398 int ordera = -1, orderb = -1;
2399
2400 if (lto_symtab_encoder_size (pa->encoder))
2401 ordera = lto_symtab_encoder_deref (pa->encoder, 0)->order;
2402 if (lto_symtab_encoder_size (pb->encoder))
2403 orderb = lto_symtab_encoder_deref (pb->encoder, 0)->order;
2404 return orderb - ordera;
2405 }
2406
2407 /* Write all output files in WPA mode and the file with the list of
2408 LTRANS units. */
2409
2410 static void
2411 lto_wpa_write_files (void)
2412 {
2413 unsigned i, n_sets;
2414 lto_file *file;
2415 ltrans_partition part;
2416 FILE *ltrans_output_list_stream;
2417 char *temp_filename;
2418 size_t blen;
2419
2420 /* Open the LTRANS output list. */
2421 if (!ltrans_output_list)
2422 fatal_error ("no LTRANS output list filename provided");
2423 ltrans_output_list_stream = fopen (ltrans_output_list, "w");
2424 if (ltrans_output_list_stream == NULL)
2425 fatal_error ("opening LTRANS output list %s: %m", ltrans_output_list);
2426
2427 timevar_push (TV_WHOPR_WPA);
2428
2429 FOR_EACH_VEC_ELT (ltrans_partitions, i, part)
2430 lto_stats.num_output_symtab_nodes += lto_symtab_encoder_size (part->encoder);
2431
2432 /* Find out statics that need to be promoted
2433 to globals with hidden visibility because they are accessed from multiple
2434 partitions. */
2435 lto_promote_cross_file_statics ();
2436
2437 timevar_pop (TV_WHOPR_WPA);
2438
2439 timevar_push (TV_WHOPR_WPA_IO);
2440
2441 /* Generate a prefix for the LTRANS unit files. */
2442 blen = strlen (ltrans_output_list);
2443 temp_filename = (char *) xmalloc (blen + sizeof ("2147483648.o"));
2444 strcpy (temp_filename, ltrans_output_list);
2445 if (blen > sizeof (".out")
2446 && strcmp (temp_filename + blen - sizeof (".out") + 1,
2447 ".out") == 0)
2448 temp_filename[blen - sizeof (".out") + 1] = '\0';
2449 blen = strlen (temp_filename);
2450
2451 n_sets = ltrans_partitions.length ();
2452
2453 /* Sort partitions by size so small ones are compiled last.
2454 FIXME: Even when not reordering we may want to output one list for parallel make
2455 and other for final link command. */
2456 ltrans_partitions.qsort (flag_toplevel_reorder
2457 ? cmp_partitions_size
2458 : cmp_partitions_order);
2459 for (i = 0; i < n_sets; i++)
2460 {
2461 size_t len;
2462 ltrans_partition part = ltrans_partitions[i];
2463
2464 /* Write all the nodes in SET. */
2465 sprintf (temp_filename + blen, "%u.o", i);
2466 file = lto_obj_file_open (temp_filename, true);
2467 if (!file)
2468 fatal_error ("lto_obj_file_open() failed");
2469
2470 if (!quiet_flag)
2471 fprintf (stderr, " %s (%s %i insns)", temp_filename, part->name, part->insns);
2472 if (cgraph_dump_file)
2473 {
2474 lto_symtab_encoder_iterator lsei;
2475
2476 fprintf (cgraph_dump_file, "Writing partition %s to file %s, %i insns\n",
2477 part->name, temp_filename, part->insns);
2478 fprintf (cgraph_dump_file, " Symbols in partition: ");
2479 for (lsei = lsei_start_in_partition (part->encoder); !lsei_end_p (lsei);
2480 lsei_next_in_partition (&lsei))
2481 {
2482 symtab_node *node = lsei_node (lsei);
2483 fprintf (cgraph_dump_file, "%s ", symtab_node_asm_name (node));
2484 }
2485 fprintf (cgraph_dump_file, "\n Symbols in boundary: ");
2486 for (lsei = lsei_start (part->encoder); !lsei_end_p (lsei);
2487 lsei_next (&lsei))
2488 {
2489 symtab_node *node = lsei_node (lsei);
2490 if (!lto_symtab_encoder_in_partition_p (part->encoder, node))
2491 {
2492 fprintf (cgraph_dump_file, "%s ", symtab_node_asm_name (node));
2493 cgraph_node *cnode = dyn_cast <cgraph_node> (node);
2494 if (cnode
2495 && lto_symtab_encoder_encode_body_p (part->encoder, cnode))
2496 fprintf (cgraph_dump_file, "(body included)");
2497 else
2498 {
2499 varpool_node *vnode = dyn_cast <varpool_node> (node);
2500 if (vnode
2501 && lto_symtab_encoder_encode_initializer_p (part->encoder, vnode))
2502 fprintf (cgraph_dump_file, "(initializer included)");
2503 }
2504 }
2505 }
2506 fprintf (cgraph_dump_file, "\n");
2507 }
2508 gcc_checking_assert (lto_symtab_encoder_size (part->encoder) || !i);
2509
2510 lto_set_current_out_file (file);
2511
2512 ipa_write_optimization_summaries (part->encoder);
2513
2514 lto_set_current_out_file (NULL);
2515 lto_obj_file_close (file);
2516 free (file);
2517 part->encoder = NULL;
2518
2519 len = strlen (temp_filename);
2520 if (fwrite (temp_filename, 1, len, ltrans_output_list_stream) < len
2521 || fwrite ("\n", 1, 1, ltrans_output_list_stream) < 1)
2522 fatal_error ("writing to LTRANS output list %s: %m",
2523 ltrans_output_list);
2524 }
2525
2526 lto_stats.num_output_files += n_sets;
2527
2528 /* Close the LTRANS output list. */
2529 if (fclose (ltrans_output_list_stream))
2530 fatal_error ("closing LTRANS output list %s: %m", ltrans_output_list);
2531
2532 free_ltrans_partitions();
2533 free (temp_filename);
2534
2535 timevar_pop (TV_WHOPR_WPA_IO);
2536 }
2537
2538
2539 /* If TT is a variable or function decl replace it with its
2540 prevailing variant. */
2541 #define LTO_SET_PREVAIL(tt) \
2542 do {\
2543 if ((tt) && VAR_OR_FUNCTION_DECL_P (tt) \
2544 && (TREE_PUBLIC (tt) || DECL_EXTERNAL (tt))) \
2545 { \
2546 tt = lto_symtab_prevailing_decl (tt); \
2547 fixed = true; \
2548 } \
2549 } while (0)
2550
2551 /* Ensure that TT isn't a replacable var of function decl. */
2552 #define LTO_NO_PREVAIL(tt) \
2553 gcc_assert (!(tt) || !VAR_OR_FUNCTION_DECL_P (tt))
2554
2555 /* Given a tree T replace all fields referring to variables or functions
2556 with their prevailing variant. */
2557 static void
2558 lto_fixup_prevailing_decls (tree t)
2559 {
2560 enum tree_code code = TREE_CODE (t);
2561 bool fixed = false;
2562
2563 gcc_checking_assert (code != CONSTRUCTOR && code != TREE_BINFO);
2564 LTO_NO_PREVAIL (TREE_TYPE (t));
2565 if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
2566 LTO_NO_PREVAIL (TREE_CHAIN (t));
2567 if (DECL_P (t))
2568 {
2569 LTO_NO_PREVAIL (DECL_NAME (t));
2570 LTO_SET_PREVAIL (DECL_CONTEXT (t));
2571 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
2572 {
2573 LTO_SET_PREVAIL (DECL_SIZE (t));
2574 LTO_SET_PREVAIL (DECL_SIZE_UNIT (t));
2575 LTO_SET_PREVAIL (DECL_INITIAL (t));
2576 LTO_NO_PREVAIL (DECL_ATTRIBUTES (t));
2577 LTO_SET_PREVAIL (DECL_ABSTRACT_ORIGIN (t));
2578 }
2579 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
2580 {
2581 LTO_NO_PREVAIL (t->decl_with_vis.assembler_name);
2582 LTO_NO_PREVAIL (DECL_SECTION_NAME (t));
2583 }
2584 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
2585 {
2586 LTO_NO_PREVAIL (DECL_ARGUMENT_FLD (t));
2587 LTO_NO_PREVAIL (DECL_RESULT_FLD (t));
2588 LTO_NO_PREVAIL (DECL_VINDEX (t));
2589 }
2590 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
2591 LTO_SET_PREVAIL (DECL_FUNCTION_PERSONALITY (t));
2592 if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
2593 {
2594 LTO_SET_PREVAIL (DECL_FIELD_OFFSET (t));
2595 LTO_NO_PREVAIL (DECL_BIT_FIELD_TYPE (t));
2596 LTO_NO_PREVAIL (DECL_QUALIFIER (t));
2597 LTO_NO_PREVAIL (DECL_FIELD_BIT_OFFSET (t));
2598 LTO_NO_PREVAIL (DECL_FCONTEXT (t));
2599 }
2600 }
2601 else if (TYPE_P (t))
2602 {
2603 LTO_NO_PREVAIL (TYPE_CACHED_VALUES (t));
2604 LTO_SET_PREVAIL (TYPE_SIZE (t));
2605 LTO_SET_PREVAIL (TYPE_SIZE_UNIT (t));
2606 LTO_NO_PREVAIL (TYPE_ATTRIBUTES (t));
2607 LTO_NO_PREVAIL (TYPE_NAME (t));
2608
2609 LTO_SET_PREVAIL (TYPE_MINVAL (t));
2610 LTO_SET_PREVAIL (TYPE_MAXVAL (t));
2611 LTO_NO_PREVAIL (t->type_non_common.binfo);
2612
2613 LTO_SET_PREVAIL (TYPE_CONTEXT (t));
2614
2615 LTO_NO_PREVAIL (TYPE_CANONICAL (t));
2616 LTO_NO_PREVAIL (TYPE_MAIN_VARIANT (t));
2617 LTO_NO_PREVAIL (TYPE_NEXT_VARIANT (t));
2618 }
2619 else if (EXPR_P (t))
2620 {
2621 int i;
2622 for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i)
2623 LTO_SET_PREVAIL (TREE_OPERAND (t, i));
2624 }
2625 else
2626 {
2627 switch (code)
2628 {
2629 case TREE_LIST:
2630 LTO_SET_PREVAIL (TREE_VALUE (t));
2631 LTO_SET_PREVAIL (TREE_PURPOSE (t));
2632 LTO_NO_PREVAIL (TREE_PURPOSE (t));
2633 break;
2634 default:
2635 gcc_unreachable ();
2636 }
2637 }
2638 /* If we fixed nothing, then we missed something seen by
2639 mentions_vars_p. */
2640 gcc_checking_assert (fixed);
2641 }
2642 #undef LTO_SET_PREVAIL
2643 #undef LTO_NO_PREVAIL
2644
2645 /* Helper function of lto_fixup_decls. Walks the var and fn streams in STATE,
2646 replaces var and function decls with the corresponding prevailing def. */
2647
2648 static void
2649 lto_fixup_state (struct lto_in_decl_state *state)
2650 {
2651 unsigned i, si;
2652 struct lto_tree_ref_table *table;
2653
2654 /* Although we only want to replace FUNCTION_DECLs and VAR_DECLs,
2655 we still need to walk from all DECLs to find the reachable
2656 FUNCTION_DECLs and VAR_DECLs. */
2657 for (si = 0; si < LTO_N_DECL_STREAMS; si++)
2658 {
2659 table = &state->streams[si];
2660 for (i = 0; i < table->size; i++)
2661 {
2662 tree *tp = table->trees + i;
2663 if (VAR_OR_FUNCTION_DECL_P (*tp)
2664 && (TREE_PUBLIC (*tp) || DECL_EXTERNAL (*tp)))
2665 *tp = lto_symtab_prevailing_decl (*tp);
2666 }
2667 }
2668 }
2669
2670 /* A callback of htab_traverse. Just extracts a state from SLOT
2671 and calls lto_fixup_state. */
2672
2673 static int
2674 lto_fixup_state_aux (void **slot, void *aux ATTRIBUTE_UNUSED)
2675 {
2676 struct lto_in_decl_state *state = (struct lto_in_decl_state *) *slot;
2677 lto_fixup_state (state);
2678 return 1;
2679 }
2680
2681 /* Fix the decls from all FILES. Replaces each decl with the corresponding
2682 prevailing one. */
2683
2684 static void
2685 lto_fixup_decls (struct lto_file_decl_data **files)
2686 {
2687 unsigned int i;
2688 tree t;
2689
2690 if (tree_with_vars)
2691 FOR_EACH_VEC_ELT ((*tree_with_vars), i, t)
2692 lto_fixup_prevailing_decls (t);
2693
2694 for (i = 0; files[i]; i++)
2695 {
2696 struct lto_file_decl_data *file = files[i];
2697 struct lto_in_decl_state *state = file->global_decl_state;
2698 lto_fixup_state (state);
2699
2700 htab_traverse (file->function_decl_states, lto_fixup_state_aux, NULL);
2701 }
2702 }
2703
2704 static GTY((length ("lto_stats.num_input_files + 1"))) struct lto_file_decl_data **all_file_decl_data;
2705
2706 /* Turn file datas for sub files into a single array, so that they look
2707 like separate files for further passes. */
2708
2709 static void
2710 lto_flatten_files (struct lto_file_decl_data **orig, int count, int last_file_ix)
2711 {
2712 struct lto_file_decl_data *n, *next;
2713 int i, k;
2714
2715 lto_stats.num_input_files = count;
2716 all_file_decl_data
2717 = ggc_alloc_cleared_vec_lto_file_decl_data_ptr (count + 1);
2718 /* Set the hooks so that all of the ipa passes can read in their data. */
2719 lto_set_in_hooks (all_file_decl_data, get_section_data, free_section_data);
2720 for (i = 0, k = 0; i < last_file_ix; i++)
2721 {
2722 for (n = orig[i]; n != NULL; n = next)
2723 {
2724 all_file_decl_data[k++] = n;
2725 next = n->next;
2726 n->next = NULL;
2727 }
2728 }
2729 all_file_decl_data[k] = NULL;
2730 gcc_assert (k == count);
2731 }
2732
2733 /* Input file data before flattening (i.e. splitting them to subfiles to support
2734 incremental linking. */
2735 static int real_file_count;
2736 static GTY((length ("real_file_count + 1"))) struct lto_file_decl_data **real_file_decl_data;
2737
2738 static void print_lto_report_1 (void);
2739
2740 /* Read all the symbols from the input files FNAMES. NFILES is the
2741 number of files requested in the command line. Instantiate a
2742 global call graph by aggregating all the sub-graphs found in each
2743 file. */
2744
2745 static void
2746 read_cgraph_and_symbols (unsigned nfiles, const char **fnames)
2747 {
2748 unsigned int i, last_file_ix;
2749 FILE *resolution;
2750 int count = 0;
2751 struct lto_file_decl_data **decl_data;
2752 void **res;
2753 symtab_node *snode;
2754
2755 init_cgraph ();
2756
2757 timevar_push (TV_IPA_LTO_DECL_IN);
2758
2759 real_file_decl_data
2760 = decl_data = ggc_alloc_cleared_vec_lto_file_decl_data_ptr (nfiles + 1);
2761 real_file_count = nfiles;
2762
2763 /* Read the resolution file. */
2764 resolution = NULL;
2765 if (resolution_file_name)
2766 {
2767 int t;
2768 unsigned num_objects;
2769
2770 resolution = fopen (resolution_file_name, "r");
2771 if (resolution == NULL)
2772 fatal_error ("could not open symbol resolution file: %m");
2773
2774 t = fscanf (resolution, "%u", &num_objects);
2775 gcc_assert (t == 1);
2776
2777 /* True, since the plugin splits the archives. */
2778 gcc_assert (num_objects == nfiles);
2779 }
2780 cgraph_state = CGRAPH_LTO_STREAMING;
2781
2782 canonical_type_hash_cache = new pointer_map <hashval_t>;
2783 gimple_canonical_types = htab_create_ggc (16381, gimple_canonical_type_hash,
2784 gimple_canonical_type_eq, 0);
2785 gcc_obstack_init (&tree_scc_hash_obstack);
2786 tree_scc_hash.create (4096);
2787
2788 /* Register the common node types with the canonical type machinery so
2789 we properly share alias-sets across languages and TUs. Do not
2790 expose the common nodes as type merge target - those that should be
2791 are already exposed so by pre-loading the LTO streamer caches.
2792 Do two passes - first clear TYPE_CANONICAL and then re-compute it. */
2793 for (i = 0; i < itk_none; ++i)
2794 lto_register_canonical_types (integer_types[i], true);
2795 for (i = 0; i < stk_type_kind_last; ++i)
2796 lto_register_canonical_types (sizetype_tab[i], true);
2797 for (i = 0; i < TI_MAX; ++i)
2798 lto_register_canonical_types (global_trees[i], true);
2799 for (i = 0; i < itk_none; ++i)
2800 lto_register_canonical_types (integer_types[i], false);
2801 for (i = 0; i < stk_type_kind_last; ++i)
2802 lto_register_canonical_types (sizetype_tab[i], false);
2803 for (i = 0; i < TI_MAX; ++i)
2804 lto_register_canonical_types (global_trees[i], false);
2805
2806 if (!quiet_flag)
2807 fprintf (stderr, "Reading object files:");
2808
2809 /* Read all of the object files specified on the command line. */
2810 for (i = 0, last_file_ix = 0; i < nfiles; ++i)
2811 {
2812 struct lto_file_decl_data *file_data = NULL;
2813 if (!quiet_flag)
2814 {
2815 fprintf (stderr, " %s", fnames[i]);
2816 fflush (stderr);
2817 }
2818
2819 current_lto_file = lto_obj_file_open (fnames[i], false);
2820 if (!current_lto_file)
2821 break;
2822
2823 file_data = lto_file_read (current_lto_file, resolution, &count);
2824 if (!file_data)
2825 {
2826 lto_obj_file_close (current_lto_file);
2827 free (current_lto_file);
2828 current_lto_file = NULL;
2829 break;
2830 }
2831
2832 decl_data[last_file_ix++] = file_data;
2833
2834 lto_obj_file_close (current_lto_file);
2835 free (current_lto_file);
2836 current_lto_file = NULL;
2837 }
2838
2839 lto_flatten_files (decl_data, count, last_file_ix);
2840 lto_stats.num_input_files = count;
2841 ggc_free(decl_data);
2842 real_file_decl_data = NULL;
2843
2844 if (resolution_file_name)
2845 fclose (resolution);
2846
2847 /* Show the LTO report before launching LTRANS. */
2848 if (flag_lto_report || (flag_wpa && flag_lto_report_wpa))
2849 print_lto_report_1 ();
2850
2851 /* Free gimple type merging datastructures. */
2852 tree_scc_hash.dispose ();
2853 obstack_free (&tree_scc_hash_obstack, NULL);
2854 htab_delete (gimple_canonical_types);
2855 gimple_canonical_types = NULL;
2856 delete canonical_type_hash_cache;
2857 canonical_type_hash_cache = NULL;
2858 ggc_collect ();
2859
2860 /* Set the hooks so that all of the ipa passes can read in their data. */
2861 lto_set_in_hooks (all_file_decl_data, get_section_data, free_section_data);
2862
2863 timevar_pop (TV_IPA_LTO_DECL_IN);
2864
2865 if (!quiet_flag)
2866 fprintf (stderr, "\nReading the callgraph\n");
2867
2868 timevar_push (TV_IPA_LTO_CGRAPH_IO);
2869 /* Read the symtab. */
2870 input_symtab ();
2871
2872 /* Store resolutions into the symbol table. */
2873
2874 FOR_EACH_SYMBOL (snode)
2875 if (symtab_real_symbol_p (snode)
2876 && snode->lto_file_data
2877 && snode->lto_file_data->resolution_map
2878 && (res = pointer_map_contains (snode->lto_file_data->resolution_map,
2879 snode->decl)))
2880 snode->resolution
2881 = (enum ld_plugin_symbol_resolution)(size_t)*res;
2882 for (i = 0; all_file_decl_data[i]; i++)
2883 if (all_file_decl_data[i]->resolution_map)
2884 {
2885 pointer_map_destroy (all_file_decl_data[i]->resolution_map);
2886 all_file_decl_data[i]->resolution_map = NULL;
2887 }
2888
2889 timevar_pop (TV_IPA_LTO_CGRAPH_IO);
2890
2891 if (!quiet_flag)
2892 fprintf (stderr, "Merging declarations\n");
2893
2894 timevar_push (TV_IPA_LTO_DECL_MERGE);
2895 /* Merge global decls. In ltrans mode we read merged cgraph, we do not
2896 need to care about resolving symbols again, we only need to replace
2897 duplicated declarations read from the callgraph and from function
2898 sections. */
2899 if (!flag_ltrans)
2900 {
2901 lto_symtab_merge_decls ();
2902
2903 /* If there were errors during symbol merging bail out, we have no
2904 good way to recover here. */
2905 if (seen_error ())
2906 fatal_error ("errors during merging of translation units");
2907
2908 /* Fixup all decls. */
2909 lto_fixup_decls (all_file_decl_data);
2910 }
2911 if (tree_with_vars)
2912 ggc_free (tree_with_vars);
2913 tree_with_vars = NULL;
2914 ggc_collect ();
2915
2916 timevar_pop (TV_IPA_LTO_DECL_MERGE);
2917 /* Each pass will set the appropriate timer. */
2918
2919 if (!quiet_flag)
2920 fprintf (stderr, "Reading summaries\n");
2921
2922 /* Read the IPA summary data. */
2923 if (flag_ltrans)
2924 ipa_read_optimization_summaries ();
2925 else
2926 ipa_read_summaries ();
2927
2928 for (i = 0; all_file_decl_data[i]; i++)
2929 {
2930 gcc_assert (all_file_decl_data[i]->symtab_node_encoder);
2931 lto_symtab_encoder_delete (all_file_decl_data[i]->symtab_node_encoder);
2932 all_file_decl_data[i]->symtab_node_encoder = NULL;
2933 lto_free_function_in_decl_state (all_file_decl_data[i]->global_decl_state);
2934 all_file_decl_data[i]->global_decl_state = NULL;
2935 all_file_decl_data[i]->current_decl_state = NULL;
2936 }
2937
2938 /* Finally merge the cgraph according to the decl merging decisions. */
2939 timevar_push (TV_IPA_LTO_CGRAPH_MERGE);
2940 if (cgraph_dump_file)
2941 {
2942 fprintf (cgraph_dump_file, "Before merging:\n");
2943 dump_symtab (cgraph_dump_file);
2944 }
2945 lto_symtab_merge_symbols ();
2946 ggc_collect ();
2947 cgraph_state = CGRAPH_STATE_IPA_SSA;
2948
2949 timevar_pop (TV_IPA_LTO_CGRAPH_MERGE);
2950
2951 timevar_push (TV_IPA_LTO_DECL_INIT_IO);
2952
2953 /* Indicate that the cgraph is built and ready. */
2954 cgraph_function_flags_ready = true;
2955
2956 timevar_pop (TV_IPA_LTO_DECL_INIT_IO);
2957 ggc_free (all_file_decl_data);
2958 all_file_decl_data = NULL;
2959 }
2960
2961
2962 /* Materialize all the bodies for all the nodes in the callgraph. */
2963
2964 static void
2965 materialize_cgraph (void)
2966 {
2967 tree decl;
2968 struct cgraph_node *node;
2969 unsigned i;
2970 timevar_id_t lto_timer;
2971
2972 if (!quiet_flag)
2973 fprintf (stderr,
2974 flag_wpa ? "Materializing decls:" : "Reading function bodies:");
2975
2976 /* Now that we have input the cgraph, we need to clear all of the aux
2977 nodes and read the functions if we are not running in WPA mode. */
2978 timevar_push (TV_IPA_LTO_GIMPLE_IN);
2979
2980 FOR_EACH_FUNCTION (node)
2981 {
2982 if (node->lto_file_data)
2983 {
2984 lto_materialize_function (node);
2985 lto_stats.num_input_cgraph_nodes++;
2986 }
2987 }
2988
2989 timevar_pop (TV_IPA_LTO_GIMPLE_IN);
2990
2991 /* Start the appropriate timer depending on the mode that we are
2992 operating in. */
2993 lto_timer = (flag_wpa) ? TV_WHOPR_WPA
2994 : (flag_ltrans) ? TV_WHOPR_LTRANS
2995 : TV_LTO;
2996 timevar_push (lto_timer);
2997
2998 current_function_decl = NULL;
2999 set_cfun (NULL);
3000
3001 /* Inform the middle end about the global variables we have seen. */
3002 FOR_EACH_VEC_ELT (*lto_global_var_decls, i, decl)
3003 rest_of_decl_compilation (decl, 1, 0);
3004
3005 if (!quiet_flag)
3006 fprintf (stderr, "\n");
3007
3008 timevar_pop (lto_timer);
3009 }
3010
3011
3012 /* Show various memory usage statistics related to LTO. */
3013 static void
3014 print_lto_report_1 (void)
3015 {
3016 const char *pfx = (flag_lto) ? "LTO" : (flag_wpa) ? "WPA" : "LTRANS";
3017 fprintf (stderr, "%s statistics\n", pfx);
3018
3019 fprintf (stderr, "[%s] read %lu SCCs of average size %f\n",
3020 pfx, num_sccs_read, total_scc_size / (double)num_sccs_read);
3021 fprintf (stderr, "[%s] %lu tree bodies read in total\n", pfx, total_scc_size);
3022 if (flag_wpa && tree_scc_hash.is_created ())
3023 {
3024 fprintf (stderr, "[%s] tree SCC table: size %ld, %ld elements, "
3025 "collision ratio: %f\n", pfx,
3026 (long) tree_scc_hash.size (),
3027 (long) tree_scc_hash.elements (),
3028 tree_scc_hash.collisions ());
3029 hash_table<tree_scc_hasher>::iterator hiter;
3030 tree_scc *scc, *max_scc = NULL;
3031 unsigned max_length = 0;
3032 FOR_EACH_HASH_TABLE_ELEMENT (tree_scc_hash, scc, x, hiter)
3033 {
3034 unsigned length = 0;
3035 tree_scc *s = scc;
3036 for (; s; s = s->next)
3037 length++;
3038 if (length > max_length)
3039 {
3040 max_length = length;
3041 max_scc = scc;
3042 }
3043 }
3044 fprintf (stderr, "[%s] tree SCC max chain length %u (size %u)\n",
3045 pfx, max_length, max_scc->len);
3046 fprintf (stderr, "[%s] Compared %lu SCCs, %lu collisions (%f)\n", pfx,
3047 num_scc_compares, num_scc_compare_collisions,
3048 num_scc_compare_collisions / (double) num_scc_compares);
3049 fprintf (stderr, "[%s] Merged %lu SCCs\n", pfx, num_sccs_merged);
3050 fprintf (stderr, "[%s] Merged %lu tree bodies\n", pfx,
3051 total_scc_size_merged);
3052 fprintf (stderr, "[%s] Merged %lu types\n", pfx, num_merged_types);
3053 fprintf (stderr, "[%s] %lu types prevailed (%lu associated trees)\n",
3054 pfx, num_prevailing_types, num_type_scc_trees);
3055 fprintf (stderr, "[%s] GIMPLE canonical type table: size %ld, "
3056 "%ld elements, %ld searches, %ld collisions (ratio: %f)\n", pfx,
3057 (long) htab_size (gimple_canonical_types),
3058 (long) htab_elements (gimple_canonical_types),
3059 (long) gimple_canonical_types->searches,
3060 (long) gimple_canonical_types->collisions,
3061 htab_collisions (gimple_canonical_types));
3062 fprintf (stderr, "[%s] GIMPLE canonical type pointer-map: "
3063 "%lu elements, %ld searches\n", pfx,
3064 num_canonical_type_hash_entries,
3065 num_canonical_type_hash_queries);
3066 }
3067
3068 print_lto_report (pfx);
3069 }
3070
3071 /* Perform whole program analysis (WPA) on the callgraph and write out the
3072 optimization plan. */
3073
3074 static void
3075 do_whole_program_analysis (void)
3076 {
3077 symtab_node *node;
3078
3079 timevar_start (TV_PHASE_OPT_GEN);
3080
3081 /* Note that since we are in WPA mode, materialize_cgraph will not
3082 actually read in all the function bodies. It only materializes
3083 the decls and cgraph nodes so that analysis can be performed. */
3084 materialize_cgraph ();
3085
3086 /* Reading in the cgraph uses different timers, start timing WPA now. */
3087 timevar_push (TV_WHOPR_WPA);
3088
3089 if (pre_ipa_mem_report)
3090 {
3091 fprintf (stderr, "Memory consumption before IPA\n");
3092 dump_memory_report (false);
3093 }
3094
3095 cgraph_function_flags_ready = true;
3096
3097 if (cgraph_dump_file)
3098 dump_symtab (cgraph_dump_file);
3099 bitmap_obstack_initialize (NULL);
3100 cgraph_state = CGRAPH_STATE_IPA_SSA;
3101
3102 execute_ipa_pass_list (g->get_passes ()->all_regular_ipa_passes);
3103 symtab_remove_unreachable_nodes (false, dump_file);
3104
3105 if (cgraph_dump_file)
3106 {
3107 fprintf (cgraph_dump_file, "Optimized ");
3108 dump_symtab (cgraph_dump_file);
3109 }
3110 #ifdef ENABLE_CHECKING
3111 verify_cgraph ();
3112 #endif
3113 bitmap_obstack_release (NULL);
3114
3115 /* We are about to launch the final LTRANS phase, stop the WPA timer. */
3116 timevar_pop (TV_WHOPR_WPA);
3117
3118 timevar_push (TV_WHOPR_PARTITIONING);
3119 if (flag_lto_partition_1to1)
3120 lto_1_to_1_map ();
3121 else if (flag_lto_partition_max)
3122 lto_max_map ();
3123 else
3124 lto_balanced_map ();
3125
3126 /* AUX pointers are used by partitioning code to bookkeep number of
3127 partitions symbol is in. This is no longer needed. */
3128 FOR_EACH_SYMBOL (node)
3129 node->aux = NULL;
3130
3131 lto_stats.num_cgraph_partitions += ltrans_partitions.length ();
3132 timevar_pop (TV_WHOPR_PARTITIONING);
3133
3134 timevar_stop (TV_PHASE_OPT_GEN);
3135 timevar_start (TV_PHASE_STREAM_OUT);
3136
3137 if (!quiet_flag)
3138 {
3139 fprintf (stderr, "\nStreaming out");
3140 fflush (stderr);
3141 }
3142 lto_wpa_write_files ();
3143 if (!quiet_flag)
3144 fprintf (stderr, "\n");
3145
3146 timevar_stop (TV_PHASE_STREAM_OUT);
3147
3148 ggc_collect ();
3149 if (post_ipa_mem_report)
3150 {
3151 fprintf (stderr, "Memory consumption after IPA\n");
3152 dump_memory_report (false);
3153 }
3154
3155 /* Show the LTO report before launching LTRANS. */
3156 if (flag_lto_report || (flag_wpa && flag_lto_report_wpa))
3157 print_lto_report_1 ();
3158 if (mem_report_wpa)
3159 dump_memory_report (true);
3160 }
3161
3162
3163 static GTY(()) tree lto_eh_personality_decl;
3164
3165 /* Return the LTO personality function decl. */
3166
3167 tree
3168 lto_eh_personality (void)
3169 {
3170 if (!lto_eh_personality_decl)
3171 {
3172 /* Use the first personality DECL for our personality if we don't
3173 support multiple ones. This ensures that we don't artificially
3174 create the need for them in a single-language program. */
3175 if (first_personality_decl && !dwarf2out_do_cfi_asm ())
3176 lto_eh_personality_decl = first_personality_decl;
3177 else
3178 lto_eh_personality_decl = lhd_gcc_personality ();
3179 }
3180
3181 return lto_eh_personality_decl;
3182 }
3183
3184 /* Set the process name based on the LTO mode. */
3185
3186 static void
3187 lto_process_name (void)
3188 {
3189 if (flag_lto)
3190 setproctitle ("lto1-lto");
3191 if (flag_wpa)
3192 setproctitle ("lto1-wpa");
3193 if (flag_ltrans)
3194 setproctitle ("lto1-ltrans");
3195 }
3196
3197
3198 /* Initialize the LTO front end. */
3199
3200 static void
3201 lto_init (void)
3202 {
3203 lto_process_name ();
3204 lto_streamer_hooks_init ();
3205 lto_reader_init ();
3206 lto_set_in_hooks (NULL, get_section_data, free_section_data);
3207 memset (&lto_stats, 0, sizeof (lto_stats));
3208 bitmap_obstack_initialize (NULL);
3209 gimple_register_cfg_hooks ();
3210 }
3211
3212
3213 /* Main entry point for the GIMPLE front end. This front end has
3214 three main personalities:
3215
3216 - LTO (-flto). All the object files on the command line are
3217 loaded in memory and processed as a single translation unit.
3218 This is the traditional link-time optimization behavior.
3219
3220 - WPA (-fwpa). Only the callgraph and summary information for
3221 files in the command file are loaded. A single callgraph
3222 (without function bodies) is instantiated for the whole set of
3223 files. IPA passes are only allowed to analyze the call graph
3224 and make transformation decisions. The callgraph is
3225 partitioned, each partition is written to a new object file
3226 together with the transformation decisions.
3227
3228 - LTRANS (-fltrans). Similar to -flto but it prevents the IPA
3229 summary files from running again. Since WPA computed summary
3230 information and decided what transformations to apply, LTRANS
3231 simply applies them. */
3232
3233 void
3234 lto_main (void)
3235 {
3236 /* LTO is called as a front end, even though it is not a front end.
3237 Because it is called as a front end, TV_PHASE_PARSING and
3238 TV_PARSE_GLOBAL are active, and we need to turn them off while
3239 doing LTO. Later we turn them back on so they are active up in
3240 toplev.c. */
3241 timevar_pop (TV_PARSE_GLOBAL);
3242 timevar_stop (TV_PHASE_PARSING);
3243
3244 timevar_start (TV_PHASE_SETUP);
3245
3246 /* Initialize the LTO front end. */
3247 lto_init ();
3248
3249 timevar_stop (TV_PHASE_SETUP);
3250 timevar_start (TV_PHASE_STREAM_IN);
3251
3252 /* Read all the symbols and call graph from all the files in the
3253 command line. */
3254 read_cgraph_and_symbols (num_in_fnames, in_fnames);
3255
3256 timevar_stop (TV_PHASE_STREAM_IN);
3257
3258 if (!seen_error ())
3259 {
3260 /* If WPA is enabled analyze the whole call graph and create an
3261 optimization plan. Otherwise, read in all the function
3262 bodies and continue with optimization. */
3263 if (flag_wpa)
3264 do_whole_program_analysis ();
3265 else
3266 {
3267 struct varpool_node *vnode;
3268
3269 timevar_start (TV_PHASE_OPT_GEN);
3270
3271 materialize_cgraph ();
3272 if (!flag_ltrans)
3273 lto_promote_statics_nonwpa ();
3274
3275 /* Let the middle end know that we have read and merged all of
3276 the input files. */
3277 compile ();
3278
3279 timevar_stop (TV_PHASE_OPT_GEN);
3280
3281 /* FIXME lto, if the processes spawned by WPA fail, we miss
3282 the chance to print WPA's report, so WPA will call
3283 print_lto_report before launching LTRANS. If LTRANS was
3284 launched directly by the driver we would not need to do
3285 this. */
3286 if (flag_lto_report || (flag_wpa && flag_lto_report_wpa))
3287 print_lto_report_1 ();
3288
3289 /* Record the global variables. */
3290 FOR_EACH_DEFINED_VARIABLE (vnode)
3291 vec_safe_push (lto_global_var_decls, vnode->decl);
3292 }
3293 }
3294
3295 /* Here we make LTO pretend to be a parser. */
3296 timevar_start (TV_PHASE_PARSING);
3297 timevar_push (TV_PARSE_GLOBAL);
3298 }
3299
3300 #include "gt-lto-lto.h"
Mirror of the offical gcc git repository hosted at gcc.gnu.org