Merge from trunk:
[official-gcc.git] / main / gcc / lto / lto.c
blob7ecdec2580899ba4b3e58b014260e5c034b332ec
1 /* Top-level LTO routines.
2 Copyright (C) 2009-2014 Free Software Foundation, Inc.
3 Contributed by CodeSourcery, Inc.
5 This file is part of GCC.
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.
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.
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/>. */
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 "stor-layout.h"
28 #include "diagnostic-core.h"
29 #include "tm.h"
30 #include "cgraph.h"
31 #include "tree-ssa-operands.h"
32 #include "tree-pass.h"
33 #include "langhooks.h"
34 #include "bitmap.h"
35 #include "hash-map.h"
36 #include "inchash.h"
37 #include "ipa-prop.h"
38 #include "common.h"
39 #include "debug.h"
40 #include "tree-ssa-alias.h"
41 #include "internal-fn.h"
42 #include "gimple-expr.h"
43 #include "is-a.h"
44 #include "gimple.h"
45 #include "lto.h"
46 #include "lto-tree.h"
47 #include "lto-streamer.h"
48 #include "lto-section-names.h"
49 #include "tree-streamer.h"
50 #include "splay-tree.h"
51 #include "lto-partition.h"
52 #include "data-streamer.h"
53 #include "context.h"
54 #include "pass_manager.h"
55 #include "ipa-inline.h"
56 #include "params.h"
59 /* Number of parallel tasks to run, -1 if we want to use GNU Make jobserver. */
60 static int lto_parallelism;
62 static GTY(()) tree first_personality_decl;
64 /* Returns a hash code for P. */
66 static hashval_t
67 hash_name (const void *p)
69 const struct lto_section_slot *ds = (const struct lto_section_slot *) p;
70 return (hashval_t) htab_hash_string (ds->name);
74 /* Returns nonzero if P1 and P2 are equal. */
76 static int
77 eq_name (const void *p1, const void *p2)
79 const struct lto_section_slot *s1 =
80 (const struct lto_section_slot *) p1;
81 const struct lto_section_slot *s2 =
82 (const struct lto_section_slot *) p2;
84 return strcmp (s1->name, s2->name) == 0;
87 /* Free lto_section_slot */
89 static void
90 free_with_string (void *arg)
92 struct lto_section_slot *s = (struct lto_section_slot *)arg;
94 free (CONST_CAST (char *, s->name));
95 free (arg);
98 /* Create section hash table */
100 htab_t
101 lto_obj_create_section_hash_table (void)
103 return htab_create (37, hash_name, eq_name, free_with_string);
106 /* Delete an allocated integer KEY in the splay tree. */
108 static void
109 lto_splay_tree_delete_id (splay_tree_key key)
111 free ((void *) key);
114 /* Compare splay tree node ids A and B. */
116 static int
117 lto_splay_tree_compare_ids (splay_tree_key a, splay_tree_key b)
119 unsigned HOST_WIDE_INT ai;
120 unsigned HOST_WIDE_INT bi;
122 ai = *(unsigned HOST_WIDE_INT *) a;
123 bi = *(unsigned HOST_WIDE_INT *) b;
125 if (ai < bi)
126 return -1;
127 else if (ai > bi)
128 return 1;
129 return 0;
132 /* Look up splay tree node by ID in splay tree T. */
134 static splay_tree_node
135 lto_splay_tree_lookup (splay_tree t, unsigned HOST_WIDE_INT id)
137 return splay_tree_lookup (t, (splay_tree_key) &id);
140 /* Check if KEY has ID. */
142 static bool
143 lto_splay_tree_id_equal_p (splay_tree_key key, unsigned HOST_WIDE_INT id)
145 return *(unsigned HOST_WIDE_INT *) key == id;
148 /* Insert a splay tree node into tree T with ID as key and FILE_DATA as value.
149 The ID is allocated separately because we need HOST_WIDE_INTs which may
150 be wider than a splay_tree_key. */
152 static void
153 lto_splay_tree_insert (splay_tree t, unsigned HOST_WIDE_INT id,
154 struct lto_file_decl_data *file_data)
156 unsigned HOST_WIDE_INT *idp = XCNEW (unsigned HOST_WIDE_INT);
157 *idp = id;
158 splay_tree_insert (t, (splay_tree_key) idp, (splay_tree_value) file_data);
161 /* Create a splay tree. */
163 static splay_tree
164 lto_splay_tree_new (void)
166 return splay_tree_new (lto_splay_tree_compare_ids,
167 lto_splay_tree_delete_id,
168 NULL);
171 /* Return true when NODE has a clone that is analyzed (i.e. we need
172 to load its body even if the node itself is not needed). */
174 static bool
175 has_analyzed_clone_p (struct cgraph_node *node)
177 struct cgraph_node *orig = node;
178 node = node->clones;
179 if (node)
180 while (node != orig)
182 if (node->analyzed)
183 return true;
184 if (node->clones)
185 node = node->clones;
186 else if (node->next_sibling_clone)
187 node = node->next_sibling_clone;
188 else
190 while (node != orig && !node->next_sibling_clone)
191 node = node->clone_of;
192 if (node != orig)
193 node = node->next_sibling_clone;
196 return false;
199 /* Read the function body for the function associated with NODE. */
201 static void
202 lto_materialize_function (struct cgraph_node *node)
204 tree decl;
206 decl = node->decl;
207 /* Read in functions with body (analyzed nodes)
208 and also functions that are needed to produce virtual clones. */
209 if ((node->has_gimple_body_p () && node->analyzed)
210 || node->used_as_abstract_origin
211 || has_analyzed_clone_p (node))
213 /* Clones don't need to be read. */
214 if (node->clone_of)
215 return;
216 if (DECL_FUNCTION_PERSONALITY (decl) && !first_personality_decl)
217 first_personality_decl = DECL_FUNCTION_PERSONALITY (decl);
220 /* Let the middle end know about the function. */
221 rest_of_decl_compilation (decl, 1, 0);
225 /* Decode the content of memory pointed to by DATA in the in decl
226 state object STATE. DATA_IN points to a data_in structure for
227 decoding. Return the address after the decoded object in the
228 input. */
230 static const uint32_t *
231 lto_read_in_decl_state (struct data_in *data_in, const uint32_t *data,
232 struct lto_in_decl_state *state)
234 uint32_t ix;
235 tree decl;
236 uint32_t i, j;
238 ix = *data++;
239 decl = streamer_tree_cache_get_tree (data_in->reader_cache, ix);
240 if (!VAR_OR_FUNCTION_DECL_P (decl))
242 gcc_assert (decl == void_type_node);
243 decl = NULL_TREE;
245 state->fn_decl = decl;
247 for (i = 0; i < LTO_N_DECL_STREAMS; i++)
249 uint32_t size = *data++;
250 tree *decls = ggc_vec_alloc<tree> (size);
252 for (j = 0; j < size; j++)
253 decls[j] = streamer_tree_cache_get_tree (data_in->reader_cache, data[j]);
255 state->streams[i].size = size;
256 state->streams[i].trees = decls;
257 data += size;
260 return data;
264 /* Global canonical type table. */
265 static htab_t gimple_canonical_types;
266 static hash_map<const_tree, hashval_t> *canonical_type_hash_cache;
267 static unsigned long num_canonical_type_hash_entries;
268 static unsigned long num_canonical_type_hash_queries;
270 static void iterative_hash_canonical_type (tree type, inchash::hash &hstate);
271 static hashval_t gimple_canonical_type_hash (const void *p);
272 static void gimple_register_canonical_type_1 (tree t, hashval_t hash);
274 /* Returning a hash value for gimple type TYPE.
276 The hash value returned is equal for types considered compatible
277 by gimple_canonical_types_compatible_p. */
279 static hashval_t
280 hash_canonical_type (tree type)
282 inchash::hash hstate;
284 /* Combine a few common features of types so that types are grouped into
285 smaller sets; when searching for existing matching types to merge,
286 only existing types having the same features as the new type will be
287 checked. */
288 hstate.add_int (TREE_CODE (type));
289 hstate.add_int (TYPE_MODE (type));
291 /* Incorporate common features of numerical types. */
292 if (INTEGRAL_TYPE_P (type)
293 || SCALAR_FLOAT_TYPE_P (type)
294 || FIXED_POINT_TYPE_P (type)
295 || TREE_CODE (type) == OFFSET_TYPE
296 || POINTER_TYPE_P (type))
298 hstate.add_int (TYPE_UNSIGNED (type));
299 hstate.add_int (TYPE_PRECISION (type));
302 if (VECTOR_TYPE_P (type))
304 hstate.add_int (TYPE_VECTOR_SUBPARTS (type));
305 hstate.add_int (TYPE_UNSIGNED (type));
308 if (TREE_CODE (type) == COMPLEX_TYPE)
309 hstate.add_int (TYPE_UNSIGNED (type));
311 /* For pointer and reference types, fold in information about the type
312 pointed to but do not recurse to the pointed-to type. */
313 if (POINTER_TYPE_P (type))
315 hstate.add_int (TYPE_ADDR_SPACE (TREE_TYPE (type)));
316 hstate.add_int (TREE_CODE (TREE_TYPE (type)));
319 /* For integer types hash only the string flag. */
320 if (TREE_CODE (type) == INTEGER_TYPE)
321 hstate.add_int (TYPE_STRING_FLAG (type));
323 /* For array types hash the domain bounds and the string flag. */
324 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
326 hstate.add_int (TYPE_STRING_FLAG (type));
327 /* OMP lowering can introduce error_mark_node in place of
328 random local decls in types. */
329 if (TYPE_MIN_VALUE (TYPE_DOMAIN (type)) != error_mark_node)
330 inchash::add_expr (TYPE_MIN_VALUE (TYPE_DOMAIN (type)), hstate);
331 if (TYPE_MAX_VALUE (TYPE_DOMAIN (type)) != error_mark_node)
332 inchash::add_expr (TYPE_MAX_VALUE (TYPE_DOMAIN (type)), hstate);
335 /* Recurse for aggregates with a single element type. */
336 if (TREE_CODE (type) == ARRAY_TYPE
337 || TREE_CODE (type) == COMPLEX_TYPE
338 || TREE_CODE (type) == VECTOR_TYPE)
339 iterative_hash_canonical_type (TREE_TYPE (type), hstate);
341 /* Incorporate function return and argument types. */
342 if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
344 unsigned na;
345 tree p;
347 /* For method types also incorporate their parent class. */
348 if (TREE_CODE (type) == METHOD_TYPE)
349 iterative_hash_canonical_type (TYPE_METHOD_BASETYPE (type), hstate);
351 iterative_hash_canonical_type (TREE_TYPE (type), hstate);
353 for (p = TYPE_ARG_TYPES (type), na = 0; p; p = TREE_CHAIN (p))
355 iterative_hash_canonical_type (TREE_VALUE (p), hstate);
356 na++;
359 hstate.add_int (na);
362 if (RECORD_OR_UNION_TYPE_P (type))
364 unsigned nf;
365 tree f;
367 for (f = TYPE_FIELDS (type), nf = 0; f; f = TREE_CHAIN (f))
368 if (TREE_CODE (f) == FIELD_DECL)
370 iterative_hash_canonical_type (TREE_TYPE (f), hstate);
371 nf++;
374 hstate.add_int (nf);
377 return hstate.end();
380 /* Returning a hash value for gimple type TYPE combined with VAL. */
382 static void
383 iterative_hash_canonical_type (tree type, inchash::hash &hstate)
385 hashval_t v;
386 /* An already processed type. */
387 if (TYPE_CANONICAL (type))
389 type = TYPE_CANONICAL (type);
390 v = gimple_canonical_type_hash (type);
392 else
394 /* Canonical types should not be able to form SCCs by design, this
395 recursion is just because we do not register canonical types in
396 optimal order. To avoid quadratic behavior also register the
397 type here. */
398 v = hash_canonical_type (type);
399 gimple_register_canonical_type_1 (type, v);
401 hstate.add_int (v);
404 /* Returns the hash for a canonical type P. */
406 static hashval_t
407 gimple_canonical_type_hash (const void *p)
409 num_canonical_type_hash_queries++;
410 hashval_t *slot = canonical_type_hash_cache->get ((const_tree) p);
411 gcc_assert (slot != NULL);
412 return *slot;
416 /* The TYPE_CANONICAL merging machinery. It should closely resemble
417 the middle-end types_compatible_p function. It needs to avoid
418 claiming types are different for types that should be treated
419 the same with respect to TBAA. Canonical types are also used
420 for IL consistency checks via the useless_type_conversion_p
421 predicate which does not handle all type kinds itself but falls
422 back to pointer-comparison of TYPE_CANONICAL for aggregates
423 for example. */
425 /* Return true iff T1 and T2 are structurally identical for what
426 TBAA is concerned. */
428 static bool
429 gimple_canonical_types_compatible_p (tree t1, tree t2)
431 /* Before starting to set up the SCC machinery handle simple cases. */
433 /* Check first for the obvious case of pointer identity. */
434 if (t1 == t2)
435 return true;
437 /* Check that we have two types to compare. */
438 if (t1 == NULL_TREE || t2 == NULL_TREE)
439 return false;
441 /* If the types have been previously registered and found equal
442 they still are. */
443 if (TYPE_CANONICAL (t1)
444 && TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2))
445 return true;
447 /* Can't be the same type if the types don't have the same code. */
448 if (TREE_CODE (t1) != TREE_CODE (t2))
449 return false;
451 /* Qualifiers do not matter for canonical type comparison purposes. */
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;
458 /* Can't be the same type if they have different mode. */
459 if (TYPE_MODE (t1) != TYPE_MODE (t2))
460 return false;
462 /* Non-aggregate types can be handled cheaply. */
463 if (INTEGRAL_TYPE_P (t1)
464 || SCALAR_FLOAT_TYPE_P (t1)
465 || FIXED_POINT_TYPE_P (t1)
466 || TREE_CODE (t1) == VECTOR_TYPE
467 || TREE_CODE (t1) == COMPLEX_TYPE
468 || TREE_CODE (t1) == OFFSET_TYPE
469 || POINTER_TYPE_P (t1))
471 /* Can't be the same type if they have different sign or precision. */
472 if (TYPE_PRECISION (t1) != TYPE_PRECISION (t2)
473 || TYPE_UNSIGNED (t1) != TYPE_UNSIGNED (t2))
474 return false;
476 if (TREE_CODE (t1) == INTEGER_TYPE
477 && TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2))
478 return false;
480 /* For canonical type comparisons we do not want to build SCCs
481 so we cannot compare pointed-to types. But we can, for now,
482 require the same pointed-to type kind and match what
483 useless_type_conversion_p would do. */
484 if (POINTER_TYPE_P (t1))
486 if (TYPE_ADDR_SPACE (TREE_TYPE (t1))
487 != TYPE_ADDR_SPACE (TREE_TYPE (t2)))
488 return false;
490 if (TREE_CODE (TREE_TYPE (t1)) != TREE_CODE (TREE_TYPE (t2)))
491 return false;
494 /* Tail-recurse to components. */
495 if (TREE_CODE (t1) == VECTOR_TYPE
496 || TREE_CODE (t1) == COMPLEX_TYPE)
497 return gimple_canonical_types_compatible_p (TREE_TYPE (t1),
498 TREE_TYPE (t2));
500 return true;
503 /* Do type-specific comparisons. */
504 switch (TREE_CODE (t1))
506 case ARRAY_TYPE:
507 /* Array types are the same if the element types are the same and
508 the number of elements are the same. */
509 if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2))
510 || TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2)
511 || TYPE_NONALIASED_COMPONENT (t1) != TYPE_NONALIASED_COMPONENT (t2))
512 return false;
513 else
515 tree i1 = TYPE_DOMAIN (t1);
516 tree i2 = TYPE_DOMAIN (t2);
518 /* For an incomplete external array, the type domain can be
519 NULL_TREE. Check this condition also. */
520 if (i1 == NULL_TREE && i2 == NULL_TREE)
521 return true;
522 else if (i1 == NULL_TREE || i2 == NULL_TREE)
523 return false;
524 else
526 tree min1 = TYPE_MIN_VALUE (i1);
527 tree min2 = TYPE_MIN_VALUE (i2);
528 tree max1 = TYPE_MAX_VALUE (i1);
529 tree max2 = TYPE_MAX_VALUE (i2);
531 /* The minimum/maximum values have to be the same. */
532 if ((min1 == min2
533 || (min1 && min2
534 && ((TREE_CODE (min1) == PLACEHOLDER_EXPR
535 && TREE_CODE (min2) == PLACEHOLDER_EXPR)
536 || operand_equal_p (min1, min2, 0))))
537 && (max1 == max2
538 || (max1 && max2
539 && ((TREE_CODE (max1) == PLACEHOLDER_EXPR
540 && TREE_CODE (max2) == PLACEHOLDER_EXPR)
541 || operand_equal_p (max1, max2, 0)))))
542 return true;
543 else
544 return false;
548 case METHOD_TYPE:
549 case FUNCTION_TYPE:
550 /* Function types are the same if the return type and arguments types
551 are the same. */
552 if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
553 return false;
555 if (!comp_type_attributes (t1, t2))
556 return false;
558 if (TYPE_ARG_TYPES (t1) == TYPE_ARG_TYPES (t2))
559 return true;
560 else
562 tree parms1, parms2;
564 for (parms1 = TYPE_ARG_TYPES (t1), parms2 = TYPE_ARG_TYPES (t2);
565 parms1 && parms2;
566 parms1 = TREE_CHAIN (parms1), parms2 = TREE_CHAIN (parms2))
568 if (!gimple_canonical_types_compatible_p
569 (TREE_VALUE (parms1), TREE_VALUE (parms2)))
570 return false;
573 if (parms1 || parms2)
574 return false;
576 return true;
579 case RECORD_TYPE:
580 case UNION_TYPE:
581 case QUAL_UNION_TYPE:
583 tree f1, f2;
585 /* For aggregate types, all the fields must be the same. */
586 for (f1 = TYPE_FIELDS (t1), f2 = TYPE_FIELDS (t2);
587 f1 || f2;
588 f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2))
590 /* Skip non-fields. */
591 while (f1 && TREE_CODE (f1) != FIELD_DECL)
592 f1 = TREE_CHAIN (f1);
593 while (f2 && TREE_CODE (f2) != FIELD_DECL)
594 f2 = TREE_CHAIN (f2);
595 if (!f1 || !f2)
596 break;
597 /* The fields must have the same name, offset and type. */
598 if (DECL_NONADDRESSABLE_P (f1) != DECL_NONADDRESSABLE_P (f2)
599 || !gimple_compare_field_offset (f1, f2)
600 || !gimple_canonical_types_compatible_p
601 (TREE_TYPE (f1), TREE_TYPE (f2)))
602 return false;
605 /* If one aggregate has more fields than the other, they
606 are not the same. */
607 if (f1 || f2)
608 return false;
610 return true;
613 default:
614 gcc_unreachable ();
619 /* Returns nonzero if P1 and P2 are equal. */
621 static int
622 gimple_canonical_type_eq (const void *p1, const void *p2)
624 const_tree t1 = (const_tree) p1;
625 const_tree t2 = (const_tree) p2;
626 return gimple_canonical_types_compatible_p (CONST_CAST_TREE (t1),
627 CONST_CAST_TREE (t2));
630 /* Main worker for gimple_register_canonical_type. */
632 static void
633 gimple_register_canonical_type_1 (tree t, hashval_t hash)
635 void **slot;
637 gcc_checking_assert (TYPE_P (t) && !TYPE_CANONICAL (t));
639 slot = htab_find_slot_with_hash (gimple_canonical_types, t, hash, INSERT);
640 if (*slot)
642 tree new_type = (tree)(*slot);
643 gcc_checking_assert (new_type != t);
644 TYPE_CANONICAL (t) = new_type;
646 else
648 TYPE_CANONICAL (t) = t;
649 *slot = (void *) t;
650 /* Cache the just computed hash value. */
651 num_canonical_type_hash_entries++;
652 bool existed_p = canonical_type_hash_cache->put (t, hash);
653 gcc_assert (!existed_p);
657 /* Register type T in the global type table gimple_types and set
658 TYPE_CANONICAL of T accordingly.
659 This is used by LTO to merge structurally equivalent types for
660 type-based aliasing purposes across different TUs and languages.
662 ??? This merging does not exactly match how the tree.c middle-end
663 functions will assign TYPE_CANONICAL when new types are created
664 during optimization (which at least happens for pointer and array
665 types). */
667 static void
668 gimple_register_canonical_type (tree t)
670 if (TYPE_CANONICAL (t))
671 return;
673 gimple_register_canonical_type_1 (t, hash_canonical_type (t));
676 /* Re-compute TYPE_CANONICAL for NODE and related types. */
678 static void
679 lto_register_canonical_types (tree node, bool first_p)
681 if (!node
682 || !TYPE_P (node))
683 return;
685 if (first_p)
686 TYPE_CANONICAL (node) = NULL_TREE;
688 if (POINTER_TYPE_P (node)
689 || TREE_CODE (node) == COMPLEX_TYPE
690 || TREE_CODE (node) == ARRAY_TYPE)
691 lto_register_canonical_types (TREE_TYPE (node), first_p);
693 if (!first_p)
694 gimple_register_canonical_type (node);
698 /* Remember trees that contains references to declarations. */
699 static GTY(()) vec <tree, va_gc> *tree_with_vars;
701 #define CHECK_VAR(tt) \
702 do \
704 if ((tt) && VAR_OR_FUNCTION_DECL_P (tt) \
705 && (TREE_PUBLIC (tt) || DECL_EXTERNAL (tt))) \
706 return true; \
707 } while (0)
709 #define CHECK_NO_VAR(tt) \
710 gcc_checking_assert (!(tt) || !VAR_OR_FUNCTION_DECL_P (tt))
712 /* Check presence of pointers to decls in fields of a tree_typed T. */
714 static inline bool
715 mentions_vars_p_typed (tree t)
717 CHECK_NO_VAR (TREE_TYPE (t));
718 return false;
721 /* Check presence of pointers to decls in fields of a tree_common T. */
723 static inline bool
724 mentions_vars_p_common (tree t)
726 if (mentions_vars_p_typed (t))
727 return true;
728 CHECK_NO_VAR (TREE_CHAIN (t));
729 return false;
732 /* Check presence of pointers to decls in fields of a decl_minimal T. */
734 static inline bool
735 mentions_vars_p_decl_minimal (tree t)
737 if (mentions_vars_p_common (t))
738 return true;
739 CHECK_NO_VAR (DECL_NAME (t));
740 CHECK_VAR (DECL_CONTEXT (t));
741 return false;
744 /* Check presence of pointers to decls in fields of a decl_common T. */
746 static inline bool
747 mentions_vars_p_decl_common (tree t)
749 if (mentions_vars_p_decl_minimal (t))
750 return true;
751 CHECK_VAR (DECL_SIZE (t));
752 CHECK_VAR (DECL_SIZE_UNIT (t));
753 CHECK_VAR (DECL_INITIAL (t));
754 CHECK_NO_VAR (DECL_ATTRIBUTES (t));
755 CHECK_VAR (DECL_ABSTRACT_ORIGIN (t));
756 return false;
759 /* Check presence of pointers to decls in fields of a decl_with_vis T. */
761 static inline bool
762 mentions_vars_p_decl_with_vis (tree t)
764 if (mentions_vars_p_decl_common (t))
765 return true;
767 /* Accessor macro has side-effects, use field-name here. */
768 CHECK_NO_VAR (t->decl_with_vis.assembler_name);
769 return false;
772 /* Check presence of pointers to decls in fields of a decl_non_common T. */
774 static inline bool
775 mentions_vars_p_decl_non_common (tree t)
777 if (mentions_vars_p_decl_with_vis (t))
778 return true;
779 CHECK_NO_VAR (DECL_RESULT_FLD (t));
780 return false;
783 /* Check presence of pointers to decls in fields of a decl_non_common T. */
785 static bool
786 mentions_vars_p_function (tree t)
788 if (mentions_vars_p_decl_non_common (t))
789 return true;
790 CHECK_NO_VAR (DECL_ARGUMENTS (t));
791 CHECK_NO_VAR (DECL_VINDEX (t));
792 CHECK_VAR (DECL_FUNCTION_PERSONALITY (t));
793 return false;
796 /* Check presence of pointers to decls in fields of a field_decl T. */
798 static bool
799 mentions_vars_p_field_decl (tree t)
801 if (mentions_vars_p_decl_common (t))
802 return true;
803 CHECK_VAR (DECL_FIELD_OFFSET (t));
804 CHECK_NO_VAR (DECL_BIT_FIELD_TYPE (t));
805 CHECK_NO_VAR (DECL_QUALIFIER (t));
806 CHECK_NO_VAR (DECL_FIELD_BIT_OFFSET (t));
807 CHECK_NO_VAR (DECL_FCONTEXT (t));
808 return false;
811 /* Check presence of pointers to decls in fields of a type T. */
813 static bool
814 mentions_vars_p_type (tree t)
816 if (mentions_vars_p_common (t))
817 return true;
818 CHECK_NO_VAR (TYPE_CACHED_VALUES (t));
819 CHECK_VAR (TYPE_SIZE (t));
820 CHECK_VAR (TYPE_SIZE_UNIT (t));
821 CHECK_NO_VAR (TYPE_ATTRIBUTES (t));
822 CHECK_NO_VAR (TYPE_NAME (t));
824 CHECK_VAR (TYPE_MINVAL (t));
825 CHECK_VAR (TYPE_MAXVAL (t));
827 /* Accessor is for derived node types only. */
828 CHECK_NO_VAR (t->type_non_common.binfo);
830 CHECK_VAR (TYPE_CONTEXT (t));
831 CHECK_NO_VAR (TYPE_CANONICAL (t));
832 CHECK_NO_VAR (TYPE_MAIN_VARIANT (t));
833 CHECK_NO_VAR (TYPE_NEXT_VARIANT (t));
834 return false;
837 /* Check presence of pointers to decls in fields of a BINFO T. */
839 static bool
840 mentions_vars_p_binfo (tree t)
842 unsigned HOST_WIDE_INT i, n;
844 if (mentions_vars_p_common (t))
845 return true;
846 CHECK_VAR (BINFO_VTABLE (t));
847 CHECK_NO_VAR (BINFO_OFFSET (t));
848 CHECK_NO_VAR (BINFO_VIRTUALS (t));
849 CHECK_NO_VAR (BINFO_VPTR_FIELD (t));
850 n = vec_safe_length (BINFO_BASE_ACCESSES (t));
851 for (i = 0; i < n; i++)
852 CHECK_NO_VAR (BINFO_BASE_ACCESS (t, i));
853 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
854 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
855 n = BINFO_N_BASE_BINFOS (t);
856 for (i = 0; i < n; i++)
857 CHECK_NO_VAR (BINFO_BASE_BINFO (t, i));
858 return false;
861 /* Check presence of pointers to decls in fields of a CONSTRUCTOR T. */
863 static bool
864 mentions_vars_p_constructor (tree t)
866 unsigned HOST_WIDE_INT idx;
867 constructor_elt *ce;
869 if (mentions_vars_p_typed (t))
870 return true;
872 for (idx = 0; vec_safe_iterate (CONSTRUCTOR_ELTS (t), idx, &ce); idx++)
874 CHECK_NO_VAR (ce->index);
875 CHECK_VAR (ce->value);
877 return false;
880 /* Check presence of pointers to decls in fields of an expression tree T. */
882 static bool
883 mentions_vars_p_expr (tree t)
885 int i;
886 if (mentions_vars_p_typed (t))
887 return true;
888 for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i)
889 CHECK_VAR (TREE_OPERAND (t, i));
890 return false;
893 /* Check presence of pointers to decls in fields of an OMP_CLAUSE T. */
895 static bool
896 mentions_vars_p_omp_clause (tree t)
898 int i;
899 if (mentions_vars_p_common (t))
900 return true;
901 for (i = omp_clause_num_ops[OMP_CLAUSE_CODE (t)] - 1; i >= 0; --i)
902 CHECK_VAR (OMP_CLAUSE_OPERAND (t, i));
903 return false;
906 /* Check presence of pointers to decls that needs later fixup in T. */
908 static bool
909 mentions_vars_p (tree t)
911 switch (TREE_CODE (t))
913 case IDENTIFIER_NODE:
914 break;
916 case TREE_LIST:
917 CHECK_VAR (TREE_VALUE (t));
918 CHECK_VAR (TREE_PURPOSE (t));
919 CHECK_NO_VAR (TREE_CHAIN (t));
920 break;
922 case FIELD_DECL:
923 return mentions_vars_p_field_decl (t);
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 case NAMELIST_DECL:
932 return mentions_vars_p_decl_common (t);
934 case VAR_DECL:
935 return mentions_vars_p_decl_with_vis (t);
937 case TYPE_DECL:
938 return mentions_vars_p_decl_non_common (t);
940 case FUNCTION_DECL:
941 return mentions_vars_p_function (t);
943 case TREE_BINFO:
944 return mentions_vars_p_binfo (t);
946 case PLACEHOLDER_EXPR:
947 return mentions_vars_p_common (t);
949 case BLOCK:
950 case TRANSLATION_UNIT_DECL:
951 case OPTIMIZATION_NODE:
952 case TARGET_OPTION_NODE:
953 break;
955 case CONSTRUCTOR:
956 return mentions_vars_p_constructor (t);
958 case OMP_CLAUSE:
959 return mentions_vars_p_omp_clause (t);
961 default:
962 if (TYPE_P (t))
964 if (mentions_vars_p_type (t))
965 return true;
967 else if (EXPR_P (t))
969 if (mentions_vars_p_expr (t))
970 return true;
972 else if (CONSTANT_CLASS_P (t))
973 CHECK_NO_VAR (TREE_TYPE (t));
974 else
975 gcc_unreachable ();
977 return false;
981 /* Return the resolution for the decl with index INDEX from DATA_IN. */
983 static enum ld_plugin_symbol_resolution
984 get_resolution (struct data_in *data_in, unsigned index)
986 if (data_in->globals_resolution.exists ())
988 ld_plugin_symbol_resolution_t ret;
989 /* We can have references to not emitted functions in
990 DECL_FUNCTION_PERSONALITY at least. So we can and have
991 to indeed return LDPR_UNKNOWN in some cases. */
992 if (data_in->globals_resolution.length () <= index)
993 return LDPR_UNKNOWN;
994 ret = data_in->globals_resolution[index];
995 return ret;
997 else
998 /* Delay resolution finding until decl merging. */
999 return LDPR_UNKNOWN;
1002 /* We need to record resolutions until symbol table is read. */
1003 static void
1004 register_resolution (struct lto_file_decl_data *file_data, tree decl,
1005 enum ld_plugin_symbol_resolution resolution)
1007 if (resolution == LDPR_UNKNOWN)
1008 return;
1009 if (!file_data->resolution_map)
1010 file_data->resolution_map = pointer_map_create ();
1011 *pointer_map_insert (file_data->resolution_map, decl) = (void *)(size_t)resolution;
1014 /* Register DECL with the global symbol table and change its
1015 name if necessary to avoid name clashes for static globals across
1016 different files. */
1018 static void
1019 lto_register_var_decl_in_symtab (struct data_in *data_in, tree decl,
1020 unsigned ix)
1022 tree context;
1024 /* Variable has file scope, not local. */
1025 if (!TREE_PUBLIC (decl)
1026 && !((context = decl_function_context (decl))
1027 && auto_var_in_fn_p (decl, context)))
1028 rest_of_decl_compilation (decl, 1, 0);
1030 /* If this variable has already been declared, queue the
1031 declaration for merging. */
1032 if (TREE_PUBLIC (decl))
1033 register_resolution (data_in->file_data,
1034 decl, get_resolution (data_in, ix));
1038 /* Register DECL with the global symbol table and change its
1039 name if necessary to avoid name clashes for static globals across
1040 different files. DATA_IN contains descriptors and tables for the
1041 file being read. */
1043 static void
1044 lto_register_function_decl_in_symtab (struct data_in *data_in, tree decl,
1045 unsigned ix)
1047 /* If this variable has already been declared, queue the
1048 declaration for merging. */
1049 if (TREE_PUBLIC (decl) && !DECL_ABSTRACT (decl))
1050 register_resolution (data_in->file_data,
1051 decl, get_resolution (data_in, ix));
1055 /* For the type T re-materialize it in the type variant list and
1056 the pointer/reference-to chains. */
1058 static void
1059 lto_fixup_prevailing_type (tree t)
1061 /* The following re-creates proper variant lists while fixing up
1062 the variant leaders. We do not stream TYPE_NEXT_VARIANT so the
1063 variant list state before fixup is broken. */
1065 /* If we are not our own variant leader link us into our new leaders
1066 variant list. */
1067 if (TYPE_MAIN_VARIANT (t) != t)
1069 tree mv = TYPE_MAIN_VARIANT (t);
1070 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (mv);
1071 TYPE_NEXT_VARIANT (mv) = t;
1074 /* The following reconstructs the pointer chains
1075 of the new pointed-to type if we are a main variant. We do
1076 not stream those so they are broken before fixup. */
1077 if (TREE_CODE (t) == POINTER_TYPE
1078 && TYPE_MAIN_VARIANT (t) == t)
1080 TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (TREE_TYPE (t));
1081 TYPE_POINTER_TO (TREE_TYPE (t)) = t;
1083 else if (TREE_CODE (t) == REFERENCE_TYPE
1084 && TYPE_MAIN_VARIANT (t) == t)
1086 TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (TREE_TYPE (t));
1087 TYPE_REFERENCE_TO (TREE_TYPE (t)) = t;
1092 /* We keep prevailing tree SCCs in a hashtable with manual collision
1093 handling (in case all hashes compare the same) and keep the colliding
1094 entries in the tree_scc->next chain. */
1096 struct tree_scc
1098 tree_scc *next;
1099 /* Hash of the whole SCC. */
1100 hashval_t hash;
1101 /* Number of trees in the SCC. */
1102 unsigned len;
1103 /* Number of possible entries into the SCC (tree nodes [0..entry_len-1]
1104 which share the same individual tree hash). */
1105 unsigned entry_len;
1106 /* The members of the SCC.
1107 We only need to remember the first entry node candidate for prevailing
1108 SCCs (but of course have access to all entries for SCCs we are
1109 processing).
1110 ??? For prevailing SCCs we really only need hash and the first
1111 entry candidate, but that's too awkward to implement. */
1112 tree entries[1];
1115 struct tree_scc_hasher : typed_noop_remove <tree_scc>
1117 typedef tree_scc value_type;
1118 typedef tree_scc compare_type;
1119 static inline hashval_t hash (const value_type *);
1120 static inline bool equal (const value_type *, const compare_type *);
1123 hashval_t
1124 tree_scc_hasher::hash (const value_type *scc)
1126 return scc->hash;
1129 bool
1130 tree_scc_hasher::equal (const value_type *scc1, const compare_type *scc2)
1132 if (scc1->hash != scc2->hash
1133 || scc1->len != scc2->len
1134 || scc1->entry_len != scc2->entry_len)
1135 return false;
1136 return true;
1139 static hash_table<tree_scc_hasher> *tree_scc_hash;
1140 static struct obstack tree_scc_hash_obstack;
1142 static unsigned long num_merged_types;
1143 static unsigned long num_prevailing_types;
1144 static unsigned long num_type_scc_trees;
1145 static unsigned long total_scc_size;
1146 static unsigned long num_sccs_read;
1147 static unsigned long total_scc_size_merged;
1148 static unsigned long num_sccs_merged;
1149 static unsigned long num_scc_compares;
1150 static unsigned long num_scc_compare_collisions;
1153 /* Compare the two entries T1 and T2 of two SCCs that are possibly equal,
1154 recursing through in-SCC tree edges. Returns true if the SCCs entered
1155 through T1 and T2 are equal and fills in *MAP with the pairs of
1156 SCC entries we visited, starting with (*MAP)[0] = T1 and (*MAP)[1] = T2. */
1158 static bool
1159 compare_tree_sccs_1 (tree t1, tree t2, tree **map)
1161 enum tree_code code;
1163 /* Mark already visited nodes. */
1164 TREE_ASM_WRITTEN (t2) = 1;
1166 /* Push the pair onto map. */
1167 (*map)[0] = t1;
1168 (*map)[1] = t2;
1169 *map = *map + 2;
1171 /* Compare value-fields. */
1172 #define compare_values(X) \
1173 do { \
1174 if (X(t1) != X(t2)) \
1175 return false; \
1176 } while (0)
1178 compare_values (TREE_CODE);
1179 code = TREE_CODE (t1);
1181 if (!TYPE_P (t1))
1183 compare_values (TREE_SIDE_EFFECTS);
1184 compare_values (TREE_CONSTANT);
1185 compare_values (TREE_READONLY);
1186 compare_values (TREE_PUBLIC);
1188 compare_values (TREE_ADDRESSABLE);
1189 compare_values (TREE_THIS_VOLATILE);
1190 if (DECL_P (t1))
1191 compare_values (DECL_UNSIGNED);
1192 else if (TYPE_P (t1))
1193 compare_values (TYPE_UNSIGNED);
1194 if (TYPE_P (t1))
1195 compare_values (TYPE_ARTIFICIAL);
1196 else
1197 compare_values (TREE_NO_WARNING);
1198 compare_values (TREE_NOTHROW);
1199 compare_values (TREE_STATIC);
1200 if (code != TREE_BINFO)
1201 compare_values (TREE_PRIVATE);
1202 compare_values (TREE_PROTECTED);
1203 compare_values (TREE_DEPRECATED);
1204 if (TYPE_P (t1))
1206 compare_values (TYPE_SATURATING);
1207 compare_values (TYPE_ADDR_SPACE);
1209 else if (code == SSA_NAME)
1210 compare_values (SSA_NAME_IS_DEFAULT_DEF);
1212 if (CODE_CONTAINS_STRUCT (code, TS_INT_CST))
1214 if (!wi::eq_p (t1, t2))
1215 return false;
1218 if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
1220 /* ??? No suitable compare routine available. */
1221 REAL_VALUE_TYPE r1 = TREE_REAL_CST (t1);
1222 REAL_VALUE_TYPE r2 = TREE_REAL_CST (t2);
1223 if (r1.cl != r2.cl
1224 || r1.decimal != r2.decimal
1225 || r1.sign != r2.sign
1226 || r1.signalling != r2.signalling
1227 || r1.canonical != r2.canonical
1228 || r1.uexp != r2.uexp)
1229 return false;
1230 for (unsigned i = 0; i < SIGSZ; ++i)
1231 if (r1.sig[i] != r2.sig[i])
1232 return false;
1235 if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
1236 if (!fixed_compare (EQ_EXPR,
1237 TREE_FIXED_CST_PTR (t1), TREE_FIXED_CST_PTR (t2)))
1238 return false;
1241 /* We don't want to compare locations, so there is nothing do compare
1242 for TS_DECL_MINIMAL. */
1244 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1246 compare_values (DECL_MODE);
1247 compare_values (DECL_NONLOCAL);
1248 compare_values (DECL_VIRTUAL_P);
1249 compare_values (DECL_IGNORED_P);
1250 compare_values (DECL_ABSTRACT);
1251 compare_values (DECL_ARTIFICIAL);
1252 compare_values (DECL_USER_ALIGN);
1253 compare_values (DECL_PRESERVE_P);
1254 compare_values (DECL_EXTERNAL);
1255 compare_values (DECL_GIMPLE_REG_P);
1256 compare_values (DECL_ALIGN);
1257 if (code == LABEL_DECL)
1259 compare_values (EH_LANDING_PAD_NR);
1260 compare_values (LABEL_DECL_UID);
1262 else if (code == FIELD_DECL)
1264 compare_values (DECL_PACKED);
1265 compare_values (DECL_NONADDRESSABLE_P);
1266 compare_values (DECL_OFFSET_ALIGN);
1268 else if (code == VAR_DECL)
1270 compare_values (DECL_HAS_DEBUG_EXPR_P);
1271 compare_values (DECL_NONLOCAL_FRAME);
1273 if (code == RESULT_DECL
1274 || code == PARM_DECL
1275 || code == VAR_DECL)
1277 compare_values (DECL_BY_REFERENCE);
1278 if (code == VAR_DECL
1279 || code == PARM_DECL)
1280 compare_values (DECL_HAS_VALUE_EXPR_P);
1284 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
1285 compare_values (DECL_REGISTER);
1287 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
1289 compare_values (DECL_COMMON);
1290 compare_values (DECL_DLLIMPORT_P);
1291 compare_values (DECL_WEAK);
1292 compare_values (DECL_SEEN_IN_BIND_EXPR_P);
1293 compare_values (DECL_COMDAT);
1294 compare_values (DECL_VISIBILITY);
1295 compare_values (DECL_VISIBILITY_SPECIFIED);
1296 if (code == VAR_DECL)
1298 compare_values (DECL_HARD_REGISTER);
1299 /* DECL_IN_TEXT_SECTION is set during final asm output only. */
1300 compare_values (DECL_IN_CONSTANT_POOL);
1304 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
1306 compare_values (DECL_BUILT_IN_CLASS);
1307 compare_values (DECL_STATIC_CONSTRUCTOR);
1308 compare_values (DECL_STATIC_DESTRUCTOR);
1309 compare_values (DECL_UNINLINABLE);
1310 compare_values (DECL_POSSIBLY_INLINED);
1311 compare_values (DECL_IS_NOVOPS);
1312 compare_values (DECL_IS_RETURNS_TWICE);
1313 compare_values (DECL_IS_MALLOC);
1314 compare_values (DECL_IS_OPERATOR_NEW);
1315 compare_values (DECL_DECLARED_INLINE_P);
1316 compare_values (DECL_STATIC_CHAIN);
1317 compare_values (DECL_NO_INLINE_WARNING_P);
1318 compare_values (DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT);
1319 compare_values (DECL_NO_LIMIT_STACK);
1320 compare_values (DECL_DISREGARD_INLINE_LIMITS);
1321 compare_values (DECL_PURE_P);
1322 compare_values (DECL_LOOPING_CONST_OR_PURE_P);
1323 compare_values (DECL_FINAL_P);
1324 compare_values (DECL_CXX_CONSTRUCTOR_P);
1325 compare_values (DECL_CXX_DESTRUCTOR_P);
1326 if (DECL_BUILT_IN_CLASS (t1) != NOT_BUILT_IN)
1327 compare_values (DECL_FUNCTION_CODE);
1330 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
1332 compare_values (TYPE_MODE);
1333 compare_values (TYPE_STRING_FLAG);
1334 compare_values (TYPE_NO_FORCE_BLK);
1335 compare_values (TYPE_NEEDS_CONSTRUCTING);
1336 if (RECORD_OR_UNION_TYPE_P (t1))
1338 compare_values (TYPE_TRANSPARENT_AGGR);
1339 compare_values (TYPE_FINAL_P);
1341 else if (code == ARRAY_TYPE)
1342 compare_values (TYPE_NONALIASED_COMPONENT);
1343 compare_values (TYPE_PACKED);
1344 compare_values (TYPE_RESTRICT);
1345 compare_values (TYPE_USER_ALIGN);
1346 compare_values (TYPE_READONLY);
1347 compare_values (TYPE_PRECISION);
1348 compare_values (TYPE_ALIGN);
1349 compare_values (TYPE_ALIAS_SET);
1352 /* We don't want to compare locations, so there is nothing do compare
1353 for TS_EXP. */
1355 /* BLOCKs are function local and we don't merge anything there, so
1356 simply refuse to merge. */
1357 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
1358 return false;
1360 if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL))
1361 if (strcmp (TRANSLATION_UNIT_LANGUAGE (t1),
1362 TRANSLATION_UNIT_LANGUAGE (t2)) != 0)
1363 return false;
1365 if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
1366 gcc_unreachable ();
1368 if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
1369 if (memcmp (TREE_OPTIMIZATION (t1), TREE_OPTIMIZATION (t2),
1370 sizeof (struct cl_optimization)) != 0)
1371 return false;
1373 if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1374 if (vec_safe_length (BINFO_BASE_ACCESSES (t1))
1375 != vec_safe_length (BINFO_BASE_ACCESSES (t2)))
1376 return false;
1378 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
1379 compare_values (CONSTRUCTOR_NELTS);
1381 if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
1382 if (IDENTIFIER_LENGTH (t1) != IDENTIFIER_LENGTH (t2)
1383 || memcmp (IDENTIFIER_POINTER (t1), IDENTIFIER_POINTER (t2),
1384 IDENTIFIER_LENGTH (t1)) != 0)
1385 return false;
1387 if (CODE_CONTAINS_STRUCT (code, TS_STRING))
1388 if (TREE_STRING_LENGTH (t1) != TREE_STRING_LENGTH (t2)
1389 || memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
1390 TREE_STRING_LENGTH (t1)) != 0)
1391 return false;
1393 if (code == OMP_CLAUSE)
1395 compare_values (OMP_CLAUSE_CODE);
1396 switch (OMP_CLAUSE_CODE (t1))
1398 case OMP_CLAUSE_DEFAULT:
1399 compare_values (OMP_CLAUSE_DEFAULT_KIND);
1400 break;
1401 case OMP_CLAUSE_SCHEDULE:
1402 compare_values (OMP_CLAUSE_SCHEDULE_KIND);
1403 break;
1404 case OMP_CLAUSE_DEPEND:
1405 compare_values (OMP_CLAUSE_DEPEND_KIND);
1406 break;
1407 case OMP_CLAUSE_MAP:
1408 compare_values (OMP_CLAUSE_MAP_KIND);
1409 break;
1410 case OMP_CLAUSE_PROC_BIND:
1411 compare_values (OMP_CLAUSE_PROC_BIND_KIND);
1412 break;
1413 case OMP_CLAUSE_REDUCTION:
1414 compare_values (OMP_CLAUSE_REDUCTION_CODE);
1415 compare_values (OMP_CLAUSE_REDUCTION_GIMPLE_INIT);
1416 compare_values (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE);
1417 break;
1418 default:
1419 break;
1423 #undef compare_values
1426 /* Compare pointer fields. */
1428 /* Recurse. Search & Replaced from DFS_write_tree_body.
1429 Folding the early checks into the compare_tree_edges recursion
1430 macro makes debugging way quicker as you are able to break on
1431 compare_tree_sccs_1 and simply finish until a call returns false
1432 to spot the SCC members with the difference. */
1433 #define compare_tree_edges(E1, E2) \
1434 do { \
1435 tree t1_ = (E1), t2_ = (E2); \
1436 if (t1_ != t2_ \
1437 && (!t1_ || !t2_ \
1438 || !TREE_VISITED (t2_) \
1439 || (!TREE_ASM_WRITTEN (t2_) \
1440 && !compare_tree_sccs_1 (t1_, t2_, map)))) \
1441 return false; \
1442 /* Only non-NULL trees outside of the SCC may compare equal. */ \
1443 gcc_checking_assert (t1_ != t2_ || (!t2_ || !TREE_VISITED (t2_))); \
1444 } while (0)
1446 if (CODE_CONTAINS_STRUCT (code, TS_TYPED))
1448 if (code != IDENTIFIER_NODE)
1449 compare_tree_edges (TREE_TYPE (t1), TREE_TYPE (t2));
1452 if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
1454 unsigned i;
1455 /* Note that the number of elements for EXPR has already been emitted
1456 in EXPR's header (see streamer_write_tree_header). */
1457 for (i = 0; i < VECTOR_CST_NELTS (t1); ++i)
1458 compare_tree_edges (VECTOR_CST_ELT (t1, i), VECTOR_CST_ELT (t2, i));
1461 if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
1463 compare_tree_edges (TREE_REALPART (t1), TREE_REALPART (t2));
1464 compare_tree_edges (TREE_IMAGPART (t1), TREE_IMAGPART (t2));
1467 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
1469 compare_tree_edges (DECL_NAME (t1), DECL_NAME (t2));
1470 /* ??? Global decls from different TUs have non-matching
1471 TRANSLATION_UNIT_DECLs. Only consider a small set of
1472 decls equivalent, we should not end up merging others. */
1473 if ((code == TYPE_DECL
1474 || code == NAMESPACE_DECL
1475 || code == IMPORTED_DECL
1476 || code == CONST_DECL
1477 || (VAR_OR_FUNCTION_DECL_P (t1)
1478 && (TREE_PUBLIC (t1) || DECL_EXTERNAL (t1))))
1479 && DECL_FILE_SCOPE_P (t1) && DECL_FILE_SCOPE_P (t2))
1481 else
1482 compare_tree_edges (DECL_CONTEXT (t1), DECL_CONTEXT (t2));
1485 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1487 compare_tree_edges (DECL_SIZE (t1), DECL_SIZE (t2));
1488 compare_tree_edges (DECL_SIZE_UNIT (t1), DECL_SIZE_UNIT (t2));
1489 compare_tree_edges (DECL_ATTRIBUTES (t1), DECL_ATTRIBUTES (t2));
1490 if ((code == VAR_DECL
1491 || code == PARM_DECL)
1492 && DECL_HAS_VALUE_EXPR_P (t1))
1493 compare_tree_edges (DECL_VALUE_EXPR (t1), DECL_VALUE_EXPR (t2));
1494 if (code == VAR_DECL
1495 && DECL_HAS_DEBUG_EXPR_P (t1))
1496 compare_tree_edges (DECL_DEBUG_EXPR (t1), DECL_DEBUG_EXPR (t2));
1497 /* LTO specific edges. */
1498 if (code != FUNCTION_DECL
1499 && code != TRANSLATION_UNIT_DECL)
1500 compare_tree_edges (DECL_INITIAL (t1), DECL_INITIAL (t2));
1503 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
1505 if (code == FUNCTION_DECL)
1507 tree a1, a2;
1508 for (a1 = DECL_ARGUMENTS (t1), a2 = DECL_ARGUMENTS (t2);
1509 a1 || a2;
1510 a1 = TREE_CHAIN (a1), a2 = TREE_CHAIN (a2))
1511 compare_tree_edges (a1, a2);
1512 compare_tree_edges (DECL_RESULT (t1), DECL_RESULT (t2));
1514 else if (code == TYPE_DECL)
1515 compare_tree_edges (DECL_ORIGINAL_TYPE (t1), DECL_ORIGINAL_TYPE (t2));
1518 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
1520 /* Make sure we don't inadvertently set the assembler name. */
1521 if (DECL_ASSEMBLER_NAME_SET_P (t1))
1522 compare_tree_edges (DECL_ASSEMBLER_NAME (t1),
1523 DECL_ASSEMBLER_NAME (t2));
1526 if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
1528 compare_tree_edges (DECL_FIELD_OFFSET (t1), DECL_FIELD_OFFSET (t2));
1529 compare_tree_edges (DECL_BIT_FIELD_TYPE (t1), DECL_BIT_FIELD_TYPE (t2));
1530 compare_tree_edges (DECL_BIT_FIELD_REPRESENTATIVE (t1),
1531 DECL_BIT_FIELD_REPRESENTATIVE (t2));
1532 compare_tree_edges (DECL_FIELD_BIT_OFFSET (t1),
1533 DECL_FIELD_BIT_OFFSET (t2));
1534 compare_tree_edges (DECL_FCONTEXT (t1), DECL_FCONTEXT (t2));
1537 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
1539 compare_tree_edges (DECL_FUNCTION_PERSONALITY (t1),
1540 DECL_FUNCTION_PERSONALITY (t2));
1541 compare_tree_edges (DECL_VINDEX (t1), DECL_VINDEX (t2));
1542 /* DECL_FUNCTION_SPECIFIC_TARGET is not yet created. We compare
1543 the attribute list instead. */
1544 compare_tree_edges (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t1),
1545 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t2));
1548 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON))
1550 compare_tree_edges (TYPE_SIZE (t1), TYPE_SIZE (t2));
1551 compare_tree_edges (TYPE_SIZE_UNIT (t1), TYPE_SIZE_UNIT (t2));
1552 compare_tree_edges (TYPE_ATTRIBUTES (t1), TYPE_ATTRIBUTES (t2));
1553 compare_tree_edges (TYPE_NAME (t1), TYPE_NAME (t2));
1554 /* Do not compare TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
1555 reconstructed during fixup. */
1556 /* Do not compare TYPE_NEXT_VARIANT, we reconstruct the variant lists
1557 during fixup. */
1558 compare_tree_edges (TYPE_MAIN_VARIANT (t1), TYPE_MAIN_VARIANT (t2));
1559 /* ??? Global types from different TUs have non-matching
1560 TRANSLATION_UNIT_DECLs. Still merge them if they are otherwise
1561 equal. */
1562 if (TYPE_FILE_SCOPE_P (t1) && TYPE_FILE_SCOPE_P (t2))
1564 else
1565 compare_tree_edges (TYPE_CONTEXT (t1), TYPE_CONTEXT (t2));
1566 /* TYPE_CANONICAL is re-computed during type merging, so do not
1567 compare it here. */
1568 compare_tree_edges (TYPE_STUB_DECL (t1), TYPE_STUB_DECL (t2));
1571 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON))
1573 if (code == ENUMERAL_TYPE)
1574 compare_tree_edges (TYPE_VALUES (t1), TYPE_VALUES (t2));
1575 else if (code == ARRAY_TYPE)
1576 compare_tree_edges (TYPE_DOMAIN (t1), TYPE_DOMAIN (t2));
1577 else if (RECORD_OR_UNION_TYPE_P (t1))
1579 tree f1, f2;
1580 for (f1 = TYPE_FIELDS (t1), f2 = TYPE_FIELDS (t2);
1581 f1 || f2;
1582 f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2))
1583 compare_tree_edges (f1, f2);
1584 compare_tree_edges (TYPE_BINFO (t1), TYPE_BINFO (t2));
1586 else if (code == FUNCTION_TYPE
1587 || code == METHOD_TYPE)
1588 compare_tree_edges (TYPE_ARG_TYPES (t1), TYPE_ARG_TYPES (t2));
1589 if (!POINTER_TYPE_P (t1))
1590 compare_tree_edges (TYPE_MINVAL (t1), TYPE_MINVAL (t2));
1591 compare_tree_edges (TYPE_MAXVAL (t1), TYPE_MAXVAL (t2));
1594 if (CODE_CONTAINS_STRUCT (code, TS_LIST))
1596 compare_tree_edges (TREE_PURPOSE (t1), TREE_PURPOSE (t2));
1597 compare_tree_edges (TREE_VALUE (t1), TREE_VALUE (t2));
1598 compare_tree_edges (TREE_CHAIN (t1), TREE_CHAIN (t2));
1601 if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1602 for (int i = 0; i < TREE_VEC_LENGTH (t1); i++)
1603 compare_tree_edges (TREE_VEC_ELT (t1, i), TREE_VEC_ELT (t2, i));
1605 if (CODE_CONTAINS_STRUCT (code, TS_EXP))
1607 for (int i = 0; i < TREE_OPERAND_LENGTH (t1); i++)
1608 compare_tree_edges (TREE_OPERAND (t1, i),
1609 TREE_OPERAND (t2, i));
1611 /* BLOCKs are function local and we don't merge anything there. */
1612 if (TREE_BLOCK (t1) || TREE_BLOCK (t2))
1613 return false;
1616 if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1618 unsigned i;
1619 tree t;
1620 /* Lengths have already been compared above. */
1621 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (t1), i, t)
1622 compare_tree_edges (t, BINFO_BASE_BINFO (t2, i));
1623 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (t1), i, t)
1624 compare_tree_edges (t, BINFO_BASE_ACCESS (t2, i));
1625 compare_tree_edges (BINFO_OFFSET (t1), BINFO_OFFSET (t2));
1626 compare_tree_edges (BINFO_VTABLE (t1), BINFO_VTABLE (t2));
1627 compare_tree_edges (BINFO_VPTR_FIELD (t1), BINFO_VPTR_FIELD (t2));
1628 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
1629 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
1632 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
1634 unsigned i;
1635 tree index, value;
1636 /* Lengths have already been compared above. */
1637 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1), i, index, value)
1639 compare_tree_edges (index, CONSTRUCTOR_ELT (t2, i)->index);
1640 compare_tree_edges (value, CONSTRUCTOR_ELT (t2, i)->value);
1644 if (code == OMP_CLAUSE)
1646 int i;
1648 for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (t1)]; i++)
1649 compare_tree_edges (OMP_CLAUSE_OPERAND (t1, i),
1650 OMP_CLAUSE_OPERAND (t2, i));
1651 compare_tree_edges (OMP_CLAUSE_CHAIN (t1), OMP_CLAUSE_CHAIN (t2));
1654 #undef compare_tree_edges
1656 return true;
1659 /* Compare the tree scc SCC to the prevailing candidate PSCC, filling
1660 out MAP if they are equal. */
1662 static bool
1663 compare_tree_sccs (tree_scc *pscc, tree_scc *scc,
1664 tree *map)
1666 /* Assume SCC entry hashes are sorted after their cardinality. Which
1667 means we can simply take the first n-tuple of equal hashes
1668 (which is recorded as entry_len) and do n SCC entry candidate
1669 comparisons. */
1670 for (unsigned i = 0; i < pscc->entry_len; ++i)
1672 tree *mapp = map;
1673 num_scc_compare_collisions++;
1674 if (compare_tree_sccs_1 (pscc->entries[0], scc->entries[i], &mapp))
1676 /* Equal - no need to reset TREE_VISITED or TREE_ASM_WRITTEN
1677 on the scc as all trees will be freed. */
1678 return true;
1680 /* Reset TREE_ASM_WRITTEN on scc for the next compare or in case
1681 the SCC prevails. */
1682 for (unsigned j = 0; j < scc->len; ++j)
1683 TREE_ASM_WRITTEN (scc->entries[j]) = 0;
1686 return false;
1689 /* QSort sort function to sort a map of two pointers after the 2nd
1690 pointer. */
1692 static int
1693 cmp_tree (const void *p1_, const void *p2_)
1695 tree *p1 = (tree *)(const_cast<void *>(p1_));
1696 tree *p2 = (tree *)(const_cast<void *>(p2_));
1697 if (p1[1] == p2[1])
1698 return 0;
1699 return ((uintptr_t)p1[1] < (uintptr_t)p2[1]) ? -1 : 1;
1702 /* Try to unify the SCC with nodes FROM to FROM + LEN in CACHE and
1703 hash value SCC_HASH with an already recorded SCC. Return true if
1704 that was successful, otherwise return false. */
1706 static bool
1707 unify_scc (struct streamer_tree_cache_d *cache, unsigned from,
1708 unsigned len, unsigned scc_entry_len, hashval_t scc_hash)
1710 bool unified_p = false;
1711 tree_scc *scc
1712 = (tree_scc *) alloca (sizeof (tree_scc) + (len - 1) * sizeof (tree));
1713 scc->next = NULL;
1714 scc->hash = scc_hash;
1715 scc->len = len;
1716 scc->entry_len = scc_entry_len;
1717 for (unsigned i = 0; i < len; ++i)
1719 tree t = streamer_tree_cache_get_tree (cache, from + i);
1720 scc->entries[i] = t;
1721 /* Do not merge SCCs with local entities inside them. Also do
1722 not merge TRANSLATION_UNIT_DECLs. */
1723 if (TREE_CODE (t) == TRANSLATION_UNIT_DECL
1724 || (VAR_OR_FUNCTION_DECL_P (t)
1725 && !(TREE_PUBLIC (t) || DECL_EXTERNAL (t)))
1726 || TREE_CODE (t) == LABEL_DECL)
1728 /* Avoid doing any work for these cases and do not worry to
1729 record the SCCs for further merging. */
1730 return false;
1734 /* Look for the list of candidate SCCs to compare against. */
1735 tree_scc **slot;
1736 slot = tree_scc_hash->find_slot_with_hash (scc, scc_hash, INSERT);
1737 if (*slot)
1739 /* Try unifying against each candidate. */
1740 num_scc_compares++;
1742 /* Set TREE_VISITED on the scc so we can easily identify tree nodes
1743 outside of the scc when following tree edges. Make sure
1744 that TREE_ASM_WRITTEN is unset so we can use it as 2nd bit
1745 to track whether we visited the SCC member during the compare.
1746 We cannot use TREE_VISITED on the pscc members as the extended
1747 scc and pscc can overlap. */
1748 for (unsigned i = 0; i < scc->len; ++i)
1750 TREE_VISITED (scc->entries[i]) = 1;
1751 gcc_checking_assert (!TREE_ASM_WRITTEN (scc->entries[i]));
1754 tree *map = XALLOCAVEC (tree, 2 * len);
1755 for (tree_scc *pscc = *slot; pscc; pscc = pscc->next)
1757 if (!compare_tree_sccs (pscc, scc, map))
1758 continue;
1760 /* Found an equal SCC. */
1761 unified_p = true;
1762 num_scc_compare_collisions--;
1763 num_sccs_merged++;
1764 total_scc_size_merged += len;
1766 #ifdef ENABLE_CHECKING
1767 for (unsigned i = 0; i < len; ++i)
1769 tree t = map[2*i+1];
1770 enum tree_code code = TREE_CODE (t);
1771 /* IDENTIFIER_NODEs should be singletons and are merged by the
1772 streamer. The others should be singletons, too, and we
1773 should not merge them in any way. */
1774 gcc_assert (code != TRANSLATION_UNIT_DECL
1775 && code != IDENTIFIER_NODE
1776 && !streamer_handle_as_builtin_p (t));
1778 #endif
1780 /* Fixup the streamer cache with the prevailing nodes according
1781 to the tree node mapping computed by compare_tree_sccs. */
1782 if (len == 1)
1783 streamer_tree_cache_replace_tree (cache, pscc->entries[0], from);
1784 else
1786 tree *map2 = XALLOCAVEC (tree, 2 * len);
1787 for (unsigned i = 0; i < len; ++i)
1789 map2[i*2] = (tree)(uintptr_t)(from + i);
1790 map2[i*2+1] = scc->entries[i];
1792 qsort (map2, len, 2 * sizeof (tree), cmp_tree);
1793 qsort (map, len, 2 * sizeof (tree), cmp_tree);
1794 for (unsigned i = 0; i < len; ++i)
1795 streamer_tree_cache_replace_tree (cache, map[2*i],
1796 (uintptr_t)map2[2*i]);
1799 /* Free the tree nodes from the read SCC. */
1800 for (unsigned i = 0; i < len; ++i)
1802 enum tree_code code;
1803 if (TYPE_P (scc->entries[i]))
1804 num_merged_types++;
1805 code = TREE_CODE (scc->entries[i]);
1806 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
1807 vec_free (CONSTRUCTOR_ELTS (scc->entries[i]));
1808 ggc_free (scc->entries[i]);
1811 break;
1814 /* Reset TREE_VISITED if we didn't unify the SCC with another. */
1815 if (!unified_p)
1816 for (unsigned i = 0; i < scc->len; ++i)
1817 TREE_VISITED (scc->entries[i]) = 0;
1820 /* If we didn't unify it to any candidate duplicate the relevant
1821 pieces to permanent storage and link it into the chain. */
1822 if (!unified_p)
1824 tree_scc *pscc
1825 = XOBNEWVAR (&tree_scc_hash_obstack, tree_scc, sizeof (tree_scc));
1826 memcpy (pscc, scc, sizeof (tree_scc));
1827 pscc->next = (*slot);
1828 *slot = pscc;
1830 return unified_p;
1834 /* Read all the symbols from buffer DATA, using descriptors in DECL_DATA.
1835 RESOLUTIONS is the set of symbols picked by the linker (read from the
1836 resolution file when the linker plugin is being used). */
1838 static void
1839 lto_read_decls (struct lto_file_decl_data *decl_data, const void *data,
1840 vec<ld_plugin_symbol_resolution_t> resolutions)
1842 const struct lto_decl_header *header = (const struct lto_decl_header *) data;
1843 const int decl_offset = sizeof (struct lto_decl_header);
1844 const int main_offset = decl_offset + header->decl_state_size;
1845 const int string_offset = main_offset + header->main_size;
1846 struct lto_input_block ib_main;
1847 struct data_in *data_in;
1848 unsigned int i;
1849 const uint32_t *data_ptr, *data_end;
1850 uint32_t num_decl_states;
1852 LTO_INIT_INPUT_BLOCK (ib_main, (const char *) data + main_offset, 0,
1853 header->main_size);
1855 data_in = lto_data_in_create (decl_data, (const char *) data + string_offset,
1856 header->string_size, resolutions);
1858 /* We do not uniquify the pre-loaded cache entries, those are middle-end
1859 internal types that should not be merged. */
1861 /* Read the global declarations and types. */
1862 while (ib_main.p < ib_main.len)
1864 tree t;
1865 unsigned from = data_in->reader_cache->nodes.length ();
1866 /* Read and uniquify SCCs as in the input stream. */
1867 enum LTO_tags tag = streamer_read_record_start (&ib_main);
1868 if (tag == LTO_tree_scc)
1870 unsigned len_;
1871 unsigned scc_entry_len;
1872 hashval_t scc_hash = lto_input_scc (&ib_main, data_in, &len_,
1873 &scc_entry_len);
1874 unsigned len = data_in->reader_cache->nodes.length () - from;
1875 gcc_assert (len == len_);
1877 total_scc_size += len;
1878 num_sccs_read++;
1880 /* We have the special case of size-1 SCCs that are pre-merged
1881 by means of identifier and string sharing for example.
1882 ??? Maybe we should avoid streaming those as SCCs. */
1883 tree first = streamer_tree_cache_get_tree (data_in->reader_cache,
1884 from);
1885 if (len == 1
1886 && (TREE_CODE (first) == IDENTIFIER_NODE
1887 || TREE_CODE (first) == INTEGER_CST
1888 || TREE_CODE (first) == TRANSLATION_UNIT_DECL
1889 || streamer_handle_as_builtin_p (first)))
1890 continue;
1892 /* Try to unify the SCC with already existing ones. */
1893 if (!flag_ltrans
1894 && unify_scc (data_in->reader_cache, from,
1895 len, scc_entry_len, scc_hash))
1896 continue;
1898 bool seen_type = false;
1899 for (unsigned i = 0; i < len; ++i)
1901 tree t = streamer_tree_cache_get_tree (data_in->reader_cache,
1902 from + i);
1903 /* Reconstruct the type variant and pointer-to/reference-to
1904 chains. */
1905 if (TYPE_P (t))
1907 seen_type = true;
1908 num_prevailing_types++;
1909 lto_fixup_prevailing_type (t);
1911 /* Compute the canonical type of all types.
1912 ??? Should be able to assert that !TYPE_CANONICAL. */
1913 if (TYPE_P (t) && !TYPE_CANONICAL (t))
1914 gimple_register_canonical_type (t);
1915 /* Link shared INTEGER_CSTs into TYPE_CACHED_VALUEs of its
1916 type which is also member of this SCC. */
1917 if (TREE_CODE (t) == INTEGER_CST
1918 && !TREE_OVERFLOW (t))
1919 cache_integer_cst (t);
1920 /* Re-build DECL_FUNCTION_SPECIFIC_TARGET, we need that
1921 for both WPA and LTRANS stage. */
1922 if (TREE_CODE (t) == FUNCTION_DECL)
1924 tree attr = lookup_attribute ("target", DECL_ATTRIBUTES (t));
1925 if (attr)
1926 targetm.target_option.valid_attribute_p
1927 (t, NULL_TREE, TREE_VALUE (attr), 0);
1929 /* Register TYPE_DECLs with the debuginfo machinery. */
1930 if (!flag_wpa
1931 && TREE_CODE (t) == TYPE_DECL)
1932 debug_hooks->type_decl (t, !DECL_FILE_SCOPE_P (t));
1933 if (!flag_ltrans)
1935 /* Register variables and functions with the
1936 symbol table. */
1937 if (TREE_CODE (t) == VAR_DECL)
1938 lto_register_var_decl_in_symtab (data_in, t, from + i);
1939 else if (TREE_CODE (t) == FUNCTION_DECL
1940 && !DECL_BUILT_IN (t))
1941 lto_register_function_decl_in_symtab (data_in, t, from + i);
1942 /* Scan the tree for references to global functions or
1943 variables and record those for later fixup. */
1944 if (mentions_vars_p (t))
1945 vec_safe_push (tree_with_vars, t);
1948 if (seen_type)
1949 num_type_scc_trees += len;
1951 else
1953 /* Pickle stray references. */
1954 t = lto_input_tree_1 (&ib_main, data_in, tag, 0);
1955 gcc_assert (t && data_in->reader_cache->nodes.length () == from);
1959 /* Read in lto_in_decl_state objects. */
1960 data_ptr = (const uint32_t *) ((const char*) data + decl_offset);
1961 data_end =
1962 (const uint32_t *) ((const char*) data_ptr + header->decl_state_size);
1963 num_decl_states = *data_ptr++;
1965 gcc_assert (num_decl_states > 0);
1966 decl_data->global_decl_state = lto_new_in_decl_state ();
1967 data_ptr = lto_read_in_decl_state (data_in, data_ptr,
1968 decl_data->global_decl_state);
1970 /* Read in per-function decl states and enter them in hash table. */
1971 decl_data->function_decl_states =
1972 htab_create_ggc (37, lto_hash_in_decl_state, lto_eq_in_decl_state, NULL);
1974 for (i = 1; i < num_decl_states; i++)
1976 struct lto_in_decl_state *state = lto_new_in_decl_state ();
1977 void **slot;
1979 data_ptr = lto_read_in_decl_state (data_in, data_ptr, state);
1980 slot = htab_find_slot (decl_data->function_decl_states, state, INSERT);
1981 gcc_assert (*slot == NULL);
1982 *slot = state;
1985 if (data_ptr != data_end)
1986 internal_error ("bytecode stream: garbage at the end of symbols section");
1988 /* Set the current decl state to be the global state. */
1989 decl_data->current_decl_state = decl_data->global_decl_state;
1991 lto_data_in_delete (data_in);
1994 /* Custom version of strtoll, which is not portable. */
1996 static int64_t
1997 lto_parse_hex (const char *p)
1999 int64_t ret = 0;
2001 for (; *p != '\0'; ++p)
2003 char c = *p;
2004 unsigned char part;
2005 ret <<= 4;
2006 if (c >= '0' && c <= '9')
2007 part = c - '0';
2008 else if (c >= 'a' && c <= 'f')
2009 part = c - 'a' + 10;
2010 else if (c >= 'A' && c <= 'F')
2011 part = c - 'A' + 10;
2012 else
2013 internal_error ("could not parse hex number");
2014 ret |= part;
2017 return ret;
2020 /* Read resolution for file named FILE_NAME. The resolution is read from
2021 RESOLUTION. */
2023 static void
2024 lto_resolution_read (splay_tree file_ids, FILE *resolution, lto_file *file)
2026 /* We require that objects in the resolution file are in the same
2027 order as the lto1 command line. */
2028 unsigned int name_len;
2029 char *obj_name;
2030 unsigned int num_symbols;
2031 unsigned int i;
2032 struct lto_file_decl_data *file_data;
2033 splay_tree_node nd = NULL;
2035 if (!resolution)
2036 return;
2038 name_len = strlen (file->filename);
2039 obj_name = XNEWVEC (char, name_len + 1);
2040 fscanf (resolution, " "); /* Read white space. */
2042 fread (obj_name, sizeof (char), name_len, resolution);
2043 obj_name[name_len] = '\0';
2044 if (filename_cmp (obj_name, file->filename) != 0)
2045 internal_error ("unexpected file name %s in linker resolution file. "
2046 "Expected %s", obj_name, file->filename);
2047 if (file->offset != 0)
2049 int t;
2050 char offset_p[17];
2051 int64_t offset;
2052 t = fscanf (resolution, "@0x%16s", offset_p);
2053 if (t != 1)
2054 internal_error ("could not parse file offset");
2055 offset = lto_parse_hex (offset_p);
2056 if (offset != file->offset)
2057 internal_error ("unexpected offset");
2060 free (obj_name);
2062 fscanf (resolution, "%u", &num_symbols);
2064 for (i = 0; i < num_symbols; i++)
2066 int t;
2067 unsigned index;
2068 unsigned HOST_WIDE_INT id;
2069 char r_str[27];
2070 enum ld_plugin_symbol_resolution r = (enum ld_plugin_symbol_resolution) 0;
2071 unsigned int j;
2072 unsigned int lto_resolution_str_len =
2073 sizeof (lto_resolution_str) / sizeof (char *);
2074 res_pair rp;
2076 t = fscanf (resolution, "%u " HOST_WIDE_INT_PRINT_HEX_PURE " %26s %*[^\n]\n",
2077 &index, &id, r_str);
2078 if (t != 3)
2079 internal_error ("invalid line in the resolution file");
2081 for (j = 0; j < lto_resolution_str_len; j++)
2083 if (strcmp (lto_resolution_str[j], r_str) == 0)
2085 r = (enum ld_plugin_symbol_resolution) j;
2086 break;
2089 if (j == lto_resolution_str_len)
2090 internal_error ("invalid resolution in the resolution file");
2092 if (!(nd && lto_splay_tree_id_equal_p (nd->key, id)))
2094 nd = lto_splay_tree_lookup (file_ids, id);
2095 if (nd == NULL)
2096 internal_error ("resolution sub id %wx not in object file", id);
2099 file_data = (struct lto_file_decl_data *)nd->value;
2100 /* The indexes are very sparse. To save memory save them in a compact
2101 format that is only unpacked later when the subfile is processed. */
2102 rp.res = r;
2103 rp.index = index;
2104 file_data->respairs.safe_push (rp);
2105 if (file_data->max_index < index)
2106 file_data->max_index = index;
2110 /* List of file_decl_datas */
2111 struct file_data_list
2113 struct lto_file_decl_data *first, *last;
2116 /* Is the name for a id'ed LTO section? */
2118 static int
2119 lto_section_with_id (const char *name, unsigned HOST_WIDE_INT *id)
2121 const char *s;
2123 if (strncmp (name, LTO_SECTION_NAME_PREFIX, strlen (LTO_SECTION_NAME_PREFIX)))
2124 return 0;
2125 s = strrchr (name, '.');
2126 return s && sscanf (s, "." HOST_WIDE_INT_PRINT_HEX_PURE, id) == 1;
2129 /* Create file_data of each sub file id */
2131 static int
2132 create_subid_section_table (struct lto_section_slot *ls, splay_tree file_ids,
2133 struct file_data_list *list)
2135 struct lto_section_slot s_slot, *new_slot;
2136 unsigned HOST_WIDE_INT id;
2137 splay_tree_node nd;
2138 void **hash_slot;
2139 char *new_name;
2140 struct lto_file_decl_data *file_data;
2142 if (!lto_section_with_id (ls->name, &id))
2143 return 1;
2145 /* Find hash table of sub module id */
2146 nd = lto_splay_tree_lookup (file_ids, id);
2147 if (nd != NULL)
2149 file_data = (struct lto_file_decl_data *)nd->value;
2151 else
2153 file_data = ggc_alloc<lto_file_decl_data> ();
2154 memset(file_data, 0, sizeof (struct lto_file_decl_data));
2155 file_data->id = id;
2156 file_data->section_hash_table = lto_obj_create_section_hash_table ();;
2157 lto_splay_tree_insert (file_ids, id, file_data);
2159 /* Maintain list in linker order */
2160 if (!list->first)
2161 list->first = file_data;
2162 if (list->last)
2163 list->last->next = file_data;
2164 list->last = file_data;
2167 /* Copy section into sub module hash table */
2168 new_name = XDUPVEC (char, ls->name, strlen (ls->name) + 1);
2169 s_slot.name = new_name;
2170 hash_slot = htab_find_slot (file_data->section_hash_table, &s_slot, INSERT);
2171 gcc_assert (*hash_slot == NULL);
2173 new_slot = XDUP (struct lto_section_slot, ls);
2174 new_slot->name = new_name;
2175 *hash_slot = new_slot;
2176 return 1;
2179 /* Read declarations and other initializations for a FILE_DATA. */
2181 static void
2182 lto_file_finalize (struct lto_file_decl_data *file_data, lto_file *file)
2184 const char *data;
2185 size_t len;
2186 vec<ld_plugin_symbol_resolution_t>
2187 resolutions = vNULL;
2188 int i;
2189 res_pair *rp;
2191 /* Create vector for fast access of resolution. We do this lazily
2192 to save memory. */
2193 resolutions.safe_grow_cleared (file_data->max_index + 1);
2194 for (i = 0; file_data->respairs.iterate (i, &rp); i++)
2195 resolutions[rp->index] = rp->res;
2196 file_data->respairs.release ();
2198 file_data->renaming_hash_table = lto_create_renaming_table ();
2199 file_data->file_name = file->filename;
2200 data = lto_get_section_data (file_data, LTO_section_decls, NULL, &len);
2201 if (data == NULL)
2203 internal_error ("cannot read LTO decls from %s", file_data->file_name);
2204 return;
2206 /* Frees resolutions */
2207 lto_read_decls (file_data, data, resolutions);
2208 lto_free_section_data (file_data, LTO_section_decls, NULL, data, len);
2211 /* Finalize FILE_DATA in FILE and increase COUNT. */
2213 static int
2214 lto_create_files_from_ids (lto_file *file, struct lto_file_decl_data *file_data,
2215 int *count)
2217 lto_file_finalize (file_data, file);
2218 if (cgraph_dump_file)
2219 fprintf (cgraph_dump_file, "Creating file %s with sub id " HOST_WIDE_INT_PRINT_HEX "\n",
2220 file_data->file_name, file_data->id);
2221 (*count)++;
2222 return 0;
2225 /* Generate a TREE representation for all types and external decls
2226 entities in FILE.
2228 Read all of the globals out of the file. Then read the cgraph
2229 and process the .o index into the cgraph nodes so that it can open
2230 the .o file to load the functions and ipa information. */
2232 static struct lto_file_decl_data *
2233 lto_file_read (lto_file *file, FILE *resolution_file, int *count)
2235 struct lto_file_decl_data *file_data = NULL;
2236 splay_tree file_ids;
2237 htab_t section_hash_table;
2238 struct lto_section_slot *section;
2239 struct file_data_list file_list;
2240 struct lto_section_list section_list;
2242 memset (&section_list, 0, sizeof (struct lto_section_list));
2243 section_hash_table = lto_obj_build_section_table (file, &section_list);
2245 /* Find all sub modules in the object and put their sections into new hash
2246 tables in a splay tree. */
2247 file_ids = lto_splay_tree_new ();
2248 memset (&file_list, 0, sizeof (struct file_data_list));
2249 for (section = section_list.first; section != NULL; section = section->next)
2250 create_subid_section_table (section, file_ids, &file_list);
2252 /* Add resolutions to file ids */
2253 lto_resolution_read (file_ids, resolution_file, file);
2255 /* Finalize each lto file for each submodule in the merged object */
2256 for (file_data = file_list.first; file_data != NULL; file_data = file_data->next)
2257 lto_create_files_from_ids (file, file_data, count);
2259 splay_tree_delete (file_ids);
2260 htab_delete (section_hash_table);
2262 return file_list.first;
2265 #if HAVE_MMAP_FILE && HAVE_SYSCONF && defined _SC_PAGE_SIZE
2266 #define LTO_MMAP_IO 1
2267 #endif
2269 #if LTO_MMAP_IO
2270 /* Page size of machine is used for mmap and munmap calls. */
2271 static size_t page_mask;
2272 #endif
2274 /* Get the section data of length LEN from FILENAME starting at
2275 OFFSET. The data segment must be freed by the caller when the
2276 caller is finished. Returns NULL if all was not well. */
2278 static char *
2279 lto_read_section_data (struct lto_file_decl_data *file_data,
2280 intptr_t offset, size_t len)
2282 char *result;
2283 static int fd = -1;
2284 static char *fd_name;
2285 #if LTO_MMAP_IO
2286 intptr_t computed_len;
2287 intptr_t computed_offset;
2288 intptr_t diff;
2289 #endif
2291 /* Keep a single-entry file-descriptor cache. The last file we
2292 touched will get closed at exit.
2293 ??? Eventually we want to add a more sophisticated larger cache
2294 or rather fix function body streaming to not stream them in
2295 practically random order. */
2296 if (fd != -1
2297 && filename_cmp (fd_name, file_data->file_name) != 0)
2299 free (fd_name);
2300 close (fd);
2301 fd = -1;
2303 if (fd == -1)
2305 fd = open (file_data->file_name, O_RDONLY|O_BINARY);
2306 if (fd == -1)
2308 fatal_error ("Cannot open %s", file_data->file_name);
2309 return NULL;
2311 fd_name = xstrdup (file_data->file_name);
2314 #if LTO_MMAP_IO
2315 if (!page_mask)
2317 size_t page_size = sysconf (_SC_PAGE_SIZE);
2318 page_mask = ~(page_size - 1);
2321 computed_offset = offset & page_mask;
2322 diff = offset - computed_offset;
2323 computed_len = len + diff;
2325 result = (char *) mmap (NULL, computed_len, PROT_READ, MAP_PRIVATE,
2326 fd, computed_offset);
2327 if (result == MAP_FAILED)
2329 fatal_error ("Cannot map %s", file_data->file_name);
2330 return NULL;
2333 return result + diff;
2334 #else
2335 result = (char *) xmalloc (len);
2336 if (lseek (fd, offset, SEEK_SET) != offset
2337 || read (fd, result, len) != (ssize_t) len)
2339 free (result);
2340 fatal_error ("Cannot read %s", file_data->file_name);
2341 result = NULL;
2343 #ifdef __MINGW32__
2344 /* Native windows doesn't supports delayed unlink on opened file. So
2345 we close file here again. This produces higher I/O load, but at least
2346 it prevents to have dangling file handles preventing unlink. */
2347 free (fd_name);
2348 fd_name = NULL;
2349 close (fd);
2350 fd = -1;
2351 #endif
2352 return result;
2353 #endif
2357 /* Get the section data from FILE_DATA of SECTION_TYPE with NAME.
2358 NAME will be NULL unless the section type is for a function
2359 body. */
2361 static const char *
2362 get_section_data (struct lto_file_decl_data *file_data,
2363 enum lto_section_type section_type,
2364 const char *name,
2365 size_t *len)
2367 htab_t section_hash_table = file_data->section_hash_table;
2368 struct lto_section_slot *f_slot;
2369 struct lto_section_slot s_slot;
2370 const char *section_name = lto_get_section_name (section_type, name, file_data);
2371 char *data = NULL;
2373 *len = 0;
2374 s_slot.name = section_name;
2375 f_slot = (struct lto_section_slot *) htab_find (section_hash_table, &s_slot);
2376 if (f_slot)
2378 data = lto_read_section_data (file_data, f_slot->start, f_slot->len);
2379 *len = f_slot->len;
2382 free (CONST_CAST (char *, section_name));
2383 return data;
2387 /* Free the section data from FILE_DATA of SECTION_TYPE with NAME that
2388 starts at OFFSET and has LEN bytes. */
2390 static void
2391 free_section_data (struct lto_file_decl_data *file_data ATTRIBUTE_UNUSED,
2392 enum lto_section_type section_type ATTRIBUTE_UNUSED,
2393 const char *name ATTRIBUTE_UNUSED,
2394 const char *offset, size_t len ATTRIBUTE_UNUSED)
2396 #if LTO_MMAP_IO
2397 intptr_t computed_len;
2398 intptr_t computed_offset;
2399 intptr_t diff;
2400 #endif
2402 #if LTO_MMAP_IO
2403 computed_offset = ((intptr_t) offset) & page_mask;
2404 diff = (intptr_t) offset - computed_offset;
2405 computed_len = len + diff;
2407 munmap ((caddr_t) computed_offset, computed_len);
2408 #else
2409 free (CONST_CAST(char *, offset));
2410 #endif
2413 static lto_file *current_lto_file;
2415 /* Helper for qsort; compare partitions and return one with smaller size.
2416 We sort from greatest to smallest so parallel build doesn't stale on the
2417 longest compilation being executed too late. */
2419 static int
2420 cmp_partitions_size (const void *a, const void *b)
2422 const struct ltrans_partition_def *pa
2423 = *(struct ltrans_partition_def *const *)a;
2424 const struct ltrans_partition_def *pb
2425 = *(struct ltrans_partition_def *const *)b;
2426 return pb->insns - pa->insns;
2429 /* Helper for qsort; compare partitions and return one with smaller order. */
2431 static int
2432 cmp_partitions_order (const void *a, const void *b)
2434 const struct ltrans_partition_def *pa
2435 = *(struct ltrans_partition_def *const *)a;
2436 const struct ltrans_partition_def *pb
2437 = *(struct ltrans_partition_def *const *)b;
2438 int ordera = -1, orderb = -1;
2440 if (lto_symtab_encoder_size (pa->encoder))
2441 ordera = lto_symtab_encoder_deref (pa->encoder, 0)->order;
2442 if (lto_symtab_encoder_size (pb->encoder))
2443 orderb = lto_symtab_encoder_deref (pb->encoder, 0)->order;
2444 return orderb - ordera;
2447 /* Actually stream out ENCODER into TEMP_FILENAME. */
2449 static void
2450 do_stream_out (char *temp_filename, lto_symtab_encoder_t encoder)
2452 lto_file *file = lto_obj_file_open (temp_filename, true);
2453 if (!file)
2454 fatal_error ("lto_obj_file_open() failed");
2455 lto_set_current_out_file (file);
2457 ipa_write_optimization_summaries (encoder);
2459 lto_set_current_out_file (NULL);
2460 lto_obj_file_close (file);
2461 free (file);
2464 /* Wait for forked process and signal errors. */
2465 #ifdef HAVE_WORKING_FORK
2466 static void
2467 wait_for_child ()
2469 int status;
2472 #ifndef WCONTINUED
2473 #define WCONTINUED 0
2474 #endif
2475 int w = waitpid (0, &status, WUNTRACED | WCONTINUED);
2476 if (w == -1)
2477 fatal_error ("waitpid failed");
2479 if (WIFEXITED (status) && WEXITSTATUS (status))
2480 fatal_error ("streaming subprocess failed");
2481 else if (WIFSIGNALED (status))
2482 fatal_error ("streaming subprocess was killed by signal");
2484 while (!WIFEXITED (status) && !WIFSIGNALED (status));
2486 #endif
2488 /* Stream out ENCODER into TEMP_FILENAME
2489 Fork if that seems to help. */
2491 static void
2492 stream_out (char *temp_filename, lto_symtab_encoder_t encoder, bool last)
2494 #ifdef HAVE_WORKING_FORK
2495 static int nruns;
2497 if (lto_parallelism <= 1)
2499 do_stream_out (temp_filename, encoder);
2500 return;
2503 /* Do not run more than LTO_PARALLELISM streamings
2504 FIXME: we ignore limits on jobserver. */
2505 if (lto_parallelism > 0 && nruns >= lto_parallelism)
2507 wait_for_child ();
2508 nruns --;
2510 /* If this is not the last parallel partition, execute new
2511 streaming process. */
2512 if (!last)
2514 pid_t cpid = fork ();
2516 if (!cpid)
2518 setproctitle ("lto1-wpa-streaming");
2519 do_stream_out (temp_filename, encoder);
2520 exit (0);
2522 /* Fork failed; lets do the job ourseleves. */
2523 else if (cpid == -1)
2524 do_stream_out (temp_filename, encoder);
2525 else
2526 nruns++;
2528 /* Last partition; stream it and wait for all children to die. */
2529 else
2531 int i;
2532 do_stream_out (temp_filename, encoder);
2533 for (i = 0; i < nruns; i++)
2534 wait_for_child ();
2536 asm_nodes_output = true;
2537 #else
2538 do_stream_out (temp_filename, encoder);
2539 #endif
2542 /* Write all output files in WPA mode and the file with the list of
2543 LTRANS units. */
2545 static void
2546 lto_wpa_write_files (void)
2548 unsigned i, n_sets;
2549 ltrans_partition part;
2550 FILE *ltrans_output_list_stream;
2551 char *temp_filename;
2552 vec <char *>temp_filenames = vNULL;
2553 size_t blen;
2555 /* Open the LTRANS output list. */
2556 if (!ltrans_output_list)
2557 fatal_error ("no LTRANS output list filename provided");
2559 timevar_push (TV_WHOPR_WPA);
2561 FOR_EACH_VEC_ELT (ltrans_partitions, i, part)
2562 lto_stats.num_output_symtab_nodes += lto_symtab_encoder_size (part->encoder);
2564 timevar_pop (TV_WHOPR_WPA);
2566 timevar_push (TV_WHOPR_WPA_IO);
2568 /* Generate a prefix for the LTRANS unit files. */
2569 blen = strlen (ltrans_output_list);
2570 temp_filename = (char *) xmalloc (blen + sizeof ("2147483648.o"));
2571 strcpy (temp_filename, ltrans_output_list);
2572 if (blen > sizeof (".out")
2573 && strcmp (temp_filename + blen - sizeof (".out") + 1,
2574 ".out") == 0)
2575 temp_filename[blen - sizeof (".out") + 1] = '\0';
2576 blen = strlen (temp_filename);
2578 n_sets = ltrans_partitions.length ();
2580 /* Sort partitions by size so small ones are compiled last.
2581 FIXME: Even when not reordering we may want to output one list for parallel make
2582 and other for final link command. */
2584 if (!flag_profile_reorder_functions || !flag_profile_use)
2585 ltrans_partitions.qsort (flag_toplevel_reorder
2586 ? cmp_partitions_size
2587 : cmp_partitions_order);
2589 for (i = 0; i < n_sets; i++)
2591 ltrans_partition part = ltrans_partitions[i];
2593 /* Write all the nodes in SET. */
2594 sprintf (temp_filename + blen, "%u.o", i);
2596 if (!quiet_flag)
2597 fprintf (stderr, " %s (%s %i insns)", temp_filename, part->name, part->insns);
2598 if (cgraph_dump_file)
2600 lto_symtab_encoder_iterator lsei;
2602 fprintf (cgraph_dump_file, "Writing partition %s to file %s, %i insns\n",
2603 part->name, temp_filename, part->insns);
2604 fprintf (cgraph_dump_file, " Symbols in partition: ");
2605 for (lsei = lsei_start_in_partition (part->encoder); !lsei_end_p (lsei);
2606 lsei_next_in_partition (&lsei))
2608 symtab_node *node = lsei_node (lsei);
2609 fprintf (cgraph_dump_file, "%s ", node->asm_name ());
2611 fprintf (cgraph_dump_file, "\n Symbols in boundary: ");
2612 for (lsei = lsei_start (part->encoder); !lsei_end_p (lsei);
2613 lsei_next (&lsei))
2615 symtab_node *node = lsei_node (lsei);
2616 if (!lto_symtab_encoder_in_partition_p (part->encoder, node))
2618 fprintf (cgraph_dump_file, "%s ", node->asm_name ());
2619 cgraph_node *cnode = dyn_cast <cgraph_node *> (node);
2620 if (cnode
2621 && lto_symtab_encoder_encode_body_p (part->encoder, cnode))
2622 fprintf (cgraph_dump_file, "(body included)");
2623 else
2625 varpool_node *vnode = dyn_cast <varpool_node *> (node);
2626 if (vnode
2627 && lto_symtab_encoder_encode_initializer_p (part->encoder, vnode))
2628 fprintf (cgraph_dump_file, "(initializer included)");
2632 fprintf (cgraph_dump_file, "\n");
2634 gcc_checking_assert (lto_symtab_encoder_size (part->encoder) || !i);
2636 stream_out (temp_filename, part->encoder, i == n_sets - 1);
2638 part->encoder = NULL;
2640 temp_filenames.safe_push (xstrdup (temp_filename));
2642 ltrans_output_list_stream = fopen (ltrans_output_list, "w");
2643 if (ltrans_output_list_stream == NULL)
2644 fatal_error ("opening LTRANS output list %s: %m", ltrans_output_list);
2645 for (i = 0; i < n_sets; i++)
2647 unsigned int len = strlen (temp_filenames[i]);
2648 if (fwrite (temp_filenames[i], 1, len, ltrans_output_list_stream) < len
2649 || fwrite ("\n", 1, 1, ltrans_output_list_stream) < 1)
2650 fatal_error ("writing to LTRANS output list %s: %m",
2651 ltrans_output_list);
2652 free (temp_filenames[i]);
2654 temp_filenames.release();
2656 lto_stats.num_output_files += n_sets;
2658 /* Close the LTRANS output list. */
2659 if (fclose (ltrans_output_list_stream))
2660 fatal_error ("closing LTRANS output list %s: %m", ltrans_output_list);
2662 free_ltrans_partitions();
2663 free (temp_filename);
2665 timevar_pop (TV_WHOPR_WPA_IO);
2669 /* If TT is a variable or function decl replace it with its
2670 prevailing variant. */
2671 #define LTO_SET_PREVAIL(tt) \
2672 do {\
2673 if ((tt) && VAR_OR_FUNCTION_DECL_P (tt) \
2674 && (TREE_PUBLIC (tt) || DECL_EXTERNAL (tt))) \
2676 tt = lto_symtab_prevailing_decl (tt); \
2677 fixed = true; \
2679 } while (0)
2681 /* Ensure that TT isn't a replacable var of function decl. */
2682 #define LTO_NO_PREVAIL(tt) \
2683 gcc_assert (!(tt) || !VAR_OR_FUNCTION_DECL_P (tt))
2685 /* Given a tree T replace all fields referring to variables or functions
2686 with their prevailing variant. */
2687 static void
2688 lto_fixup_prevailing_decls (tree t)
2690 enum tree_code code = TREE_CODE (t);
2691 bool fixed = false;
2693 gcc_checking_assert (code != TREE_BINFO);
2694 LTO_NO_PREVAIL (TREE_TYPE (t));
2695 if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
2696 LTO_NO_PREVAIL (TREE_CHAIN (t));
2697 if (DECL_P (t))
2699 LTO_NO_PREVAIL (DECL_NAME (t));
2700 LTO_SET_PREVAIL (DECL_CONTEXT (t));
2701 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
2703 LTO_SET_PREVAIL (DECL_SIZE (t));
2704 LTO_SET_PREVAIL (DECL_SIZE_UNIT (t));
2705 LTO_SET_PREVAIL (DECL_INITIAL (t));
2706 LTO_NO_PREVAIL (DECL_ATTRIBUTES (t));
2707 LTO_SET_PREVAIL (DECL_ABSTRACT_ORIGIN (t));
2709 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
2711 LTO_NO_PREVAIL (t->decl_with_vis.assembler_name);
2713 if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
2715 LTO_NO_PREVAIL (DECL_RESULT_FLD (t));
2717 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
2719 LTO_NO_PREVAIL (DECL_ARGUMENTS (t));
2720 LTO_SET_PREVAIL (DECL_FUNCTION_PERSONALITY (t));
2721 LTO_NO_PREVAIL (DECL_VINDEX (t));
2723 if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
2725 LTO_SET_PREVAIL (DECL_FIELD_OFFSET (t));
2726 LTO_NO_PREVAIL (DECL_BIT_FIELD_TYPE (t));
2727 LTO_NO_PREVAIL (DECL_QUALIFIER (t));
2728 LTO_NO_PREVAIL (DECL_FIELD_BIT_OFFSET (t));
2729 LTO_NO_PREVAIL (DECL_FCONTEXT (t));
2732 else if (TYPE_P (t))
2734 LTO_NO_PREVAIL (TYPE_CACHED_VALUES (t));
2735 LTO_SET_PREVAIL (TYPE_SIZE (t));
2736 LTO_SET_PREVAIL (TYPE_SIZE_UNIT (t));
2737 LTO_NO_PREVAIL (TYPE_ATTRIBUTES (t));
2738 LTO_NO_PREVAIL (TYPE_NAME (t));
2740 LTO_SET_PREVAIL (TYPE_MINVAL (t));
2741 LTO_SET_PREVAIL (TYPE_MAXVAL (t));
2742 LTO_NO_PREVAIL (t->type_non_common.binfo);
2744 LTO_SET_PREVAIL (TYPE_CONTEXT (t));
2746 LTO_NO_PREVAIL (TYPE_CANONICAL (t));
2747 LTO_NO_PREVAIL (TYPE_MAIN_VARIANT (t));
2748 LTO_NO_PREVAIL (TYPE_NEXT_VARIANT (t));
2750 else if (EXPR_P (t))
2752 int i;
2753 for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i)
2754 LTO_SET_PREVAIL (TREE_OPERAND (t, i));
2756 else if (TREE_CODE (t) == CONSTRUCTOR)
2758 unsigned i;
2759 tree val;
2760 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t), i, val)
2761 LTO_SET_PREVAIL (val);
2763 else
2765 switch (code)
2767 case TREE_LIST:
2768 LTO_SET_PREVAIL (TREE_VALUE (t));
2769 LTO_SET_PREVAIL (TREE_PURPOSE (t));
2770 LTO_NO_PREVAIL (TREE_PURPOSE (t));
2771 break;
2772 default:
2773 gcc_unreachable ();
2776 /* If we fixed nothing, then we missed something seen by
2777 mentions_vars_p. */
2778 gcc_checking_assert (fixed);
2780 #undef LTO_SET_PREVAIL
2781 #undef LTO_NO_PREVAIL
2783 /* Helper function of lto_fixup_decls. Walks the var and fn streams in STATE,
2784 replaces var and function decls with the corresponding prevailing def. */
2786 static void
2787 lto_fixup_state (struct lto_in_decl_state *state)
2789 unsigned i, si;
2790 struct lto_tree_ref_table *table;
2792 /* Although we only want to replace FUNCTION_DECLs and VAR_DECLs,
2793 we still need to walk from all DECLs to find the reachable
2794 FUNCTION_DECLs and VAR_DECLs. */
2795 for (si = 0; si < LTO_N_DECL_STREAMS; si++)
2797 table = &state->streams[si];
2798 for (i = 0; i < table->size; i++)
2800 tree *tp = table->trees + i;
2801 if (VAR_OR_FUNCTION_DECL_P (*tp)
2802 && (TREE_PUBLIC (*tp) || DECL_EXTERNAL (*tp)))
2803 *tp = lto_symtab_prevailing_decl (*tp);
2808 /* A callback of htab_traverse. Just extracts a state from SLOT
2809 and calls lto_fixup_state. */
2811 static int
2812 lto_fixup_state_aux (void **slot, void *aux ATTRIBUTE_UNUSED)
2814 struct lto_in_decl_state *state = (struct lto_in_decl_state *) *slot;
2815 lto_fixup_state (state);
2816 return 1;
2819 /* Fix the decls from all FILES. Replaces each decl with the corresponding
2820 prevailing one. */
2822 static void
2823 lto_fixup_decls (struct lto_file_decl_data **files)
2825 unsigned int i;
2826 tree t;
2828 if (tree_with_vars)
2829 FOR_EACH_VEC_ELT ((*tree_with_vars), i, t)
2830 lto_fixup_prevailing_decls (t);
2832 for (i = 0; files[i]; i++)
2834 struct lto_file_decl_data *file = files[i];
2835 struct lto_in_decl_state *state = file->global_decl_state;
2836 lto_fixup_state (state);
2838 htab_traverse (file->function_decl_states, lto_fixup_state_aux, NULL);
2842 static GTY((length ("lto_stats.num_input_files + 1"))) struct lto_file_decl_data **all_file_decl_data;
2844 /* Turn file datas for sub files into a single array, so that they look
2845 like separate files for further passes. */
2847 static void
2848 lto_flatten_files (struct lto_file_decl_data **orig, int count, int last_file_ix)
2850 struct lto_file_decl_data *n, *next;
2851 int i, k;
2853 lto_stats.num_input_files = count;
2854 all_file_decl_data
2855 = ggc_cleared_vec_alloc<lto_file_decl_data_ptr> (count + 1);
2856 /* Set the hooks so that all of the ipa passes can read in their data. */
2857 lto_set_in_hooks (all_file_decl_data, get_section_data, free_section_data);
2858 for (i = 0, k = 0; i < last_file_ix; i++)
2860 for (n = orig[i]; n != NULL; n = next)
2862 all_file_decl_data[k++] = n;
2863 next = n->next;
2864 n->next = NULL;
2867 all_file_decl_data[k] = NULL;
2868 gcc_assert (k == count);
2871 /* Input file data before flattening (i.e. splitting them to subfiles to support
2872 incremental linking. */
2873 static int real_file_count;
2874 static GTY((length ("real_file_count + 1"))) struct lto_file_decl_data **real_file_decl_data;
2876 static void print_lto_report_1 (void);
2878 /* Read all the symbols from the input files FNAMES. NFILES is the
2879 number of files requested in the command line. Instantiate a
2880 global call graph by aggregating all the sub-graphs found in each
2881 file. */
2883 static void
2884 read_cgraph_and_symbols (unsigned nfiles, const char **fnames)
2886 unsigned int i, last_file_ix;
2887 FILE *resolution;
2888 int count = 0;
2889 struct lto_file_decl_data **decl_data;
2890 void **res;
2891 symtab_node *snode;
2893 init_cgraph ();
2895 timevar_push (TV_IPA_LTO_DECL_IN);
2897 real_file_decl_data
2898 = decl_data = ggc_cleared_vec_alloc<lto_file_decl_data_ptr> (nfiles + 1);
2899 real_file_count = nfiles;
2901 /* Read the resolution file. */
2902 resolution = NULL;
2903 if (resolution_file_name)
2905 int t;
2906 unsigned num_objects;
2908 resolution = fopen (resolution_file_name, "r");
2909 if (resolution == NULL)
2910 fatal_error ("could not open symbol resolution file: %m");
2912 t = fscanf (resolution, "%u", &num_objects);
2913 gcc_assert (t == 1);
2915 /* True, since the plugin splits the archives. */
2916 gcc_assert (num_objects == nfiles);
2918 cgraph_state = CGRAPH_LTO_STREAMING;
2920 canonical_type_hash_cache = new hash_map<const_tree, hashval_t> (251);
2921 gimple_canonical_types = htab_create_ggc (16381, gimple_canonical_type_hash,
2922 gimple_canonical_type_eq, 0);
2923 gcc_obstack_init (&tree_scc_hash_obstack);
2924 tree_scc_hash = new hash_table<tree_scc_hasher> (4096);
2926 /* Register the common node types with the canonical type machinery so
2927 we properly share alias-sets across languages and TUs. Do not
2928 expose the common nodes as type merge target - those that should be
2929 are already exposed so by pre-loading the LTO streamer caches.
2930 Do two passes - first clear TYPE_CANONICAL and then re-compute it. */
2931 for (i = 0; i < itk_none; ++i)
2932 lto_register_canonical_types (integer_types[i], true);
2933 for (i = 0; i < stk_type_kind_last; ++i)
2934 lto_register_canonical_types (sizetype_tab[i], true);
2935 for (i = 0; i < TI_MAX; ++i)
2936 lto_register_canonical_types (global_trees[i], true);
2937 for (i = 0; i < itk_none; ++i)
2938 lto_register_canonical_types (integer_types[i], false);
2939 for (i = 0; i < stk_type_kind_last; ++i)
2940 lto_register_canonical_types (sizetype_tab[i], false);
2941 for (i = 0; i < TI_MAX; ++i)
2942 lto_register_canonical_types (global_trees[i], false);
2944 if (!quiet_flag)
2945 fprintf (stderr, "Reading object files:");
2947 /* Read all of the object files specified on the command line. */
2948 for (i = 0, last_file_ix = 0; i < nfiles; ++i)
2950 struct lto_file_decl_data *file_data = NULL;
2951 if (!quiet_flag)
2953 fprintf (stderr, " %s", fnames[i]);
2954 fflush (stderr);
2957 current_lto_file = lto_obj_file_open (fnames[i], false);
2958 if (!current_lto_file)
2959 break;
2961 file_data = lto_file_read (current_lto_file, resolution, &count);
2962 if (!file_data)
2964 lto_obj_file_close (current_lto_file);
2965 free (current_lto_file);
2966 current_lto_file = NULL;
2967 break;
2970 decl_data[last_file_ix++] = file_data;
2972 lto_obj_file_close (current_lto_file);
2973 free (current_lto_file);
2974 current_lto_file = NULL;
2977 lto_flatten_files (decl_data, count, last_file_ix);
2978 lto_stats.num_input_files = count;
2979 ggc_free(decl_data);
2980 real_file_decl_data = NULL;
2982 if (resolution_file_name)
2983 fclose (resolution);
2985 /* Show the LTO report before launching LTRANS. */
2986 if (flag_lto_report || (flag_wpa && flag_lto_report_wpa))
2987 print_lto_report_1 ();
2989 /* Free gimple type merging datastructures. */
2990 delete tree_scc_hash;
2991 tree_scc_hash = NULL;
2992 obstack_free (&tree_scc_hash_obstack, NULL);
2993 htab_delete (gimple_canonical_types);
2994 gimple_canonical_types = NULL;
2995 delete canonical_type_hash_cache;
2996 canonical_type_hash_cache = NULL;
2998 /* At this stage we know that majority of GGC memory is reachable.
2999 Growing the limits prevents unnecesary invocation of GGC. */
3000 ggc_grow ();
3001 ggc_collect ();
3003 /* Set the hooks so that all of the ipa passes can read in their data. */
3004 lto_set_in_hooks (all_file_decl_data, get_section_data, free_section_data);
3006 timevar_pop (TV_IPA_LTO_DECL_IN);
3008 if (!quiet_flag)
3009 fprintf (stderr, "\nReading the callgraph\n");
3011 timevar_push (TV_IPA_LTO_CGRAPH_IO);
3012 /* Read the symtab. */
3013 input_symtab ();
3015 /* Store resolutions into the symbol table. */
3017 FOR_EACH_SYMBOL (snode)
3018 if (snode->real_symbol_p ()
3019 && snode->lto_file_data
3020 && snode->lto_file_data->resolution_map
3021 && (res = pointer_map_contains (snode->lto_file_data->resolution_map,
3022 snode->decl)))
3023 snode->resolution
3024 = (enum ld_plugin_symbol_resolution)(size_t)*res;
3025 for (i = 0; all_file_decl_data[i]; i++)
3026 if (all_file_decl_data[i]->resolution_map)
3028 pointer_map_destroy (all_file_decl_data[i]->resolution_map);
3029 all_file_decl_data[i]->resolution_map = NULL;
3032 timevar_pop (TV_IPA_LTO_CGRAPH_IO);
3034 if (!quiet_flag)
3035 fprintf (stderr, "Merging declarations\n");
3037 timevar_push (TV_IPA_LTO_DECL_MERGE);
3038 /* Merge global decls. In ltrans mode we read merged cgraph, we do not
3039 need to care about resolving symbols again, we only need to replace
3040 duplicated declarations read from the callgraph and from function
3041 sections. */
3042 if (!flag_ltrans)
3044 lto_symtab_merge_decls ();
3046 /* If there were errors during symbol merging bail out, we have no
3047 good way to recover here. */
3048 if (seen_error ())
3049 fatal_error ("errors during merging of translation units");
3051 /* Fixup all decls. */
3052 lto_fixup_decls (all_file_decl_data);
3054 if (tree_with_vars)
3055 ggc_free (tree_with_vars);
3056 tree_with_vars = NULL;
3057 ggc_collect ();
3059 timevar_pop (TV_IPA_LTO_DECL_MERGE);
3060 /* Each pass will set the appropriate timer. */
3062 if (!quiet_flag)
3063 fprintf (stderr, "Reading summaries\n");
3065 /* Read the IPA summary data. */
3066 if (flag_ltrans)
3067 ipa_read_optimization_summaries ();
3068 else
3069 ipa_read_summaries ();
3071 for (i = 0; all_file_decl_data[i]; i++)
3073 gcc_assert (all_file_decl_data[i]->symtab_node_encoder);
3074 lto_symtab_encoder_delete (all_file_decl_data[i]->symtab_node_encoder);
3075 all_file_decl_data[i]->symtab_node_encoder = NULL;
3076 lto_free_function_in_decl_state (all_file_decl_data[i]->global_decl_state);
3077 all_file_decl_data[i]->global_decl_state = NULL;
3078 all_file_decl_data[i]->current_decl_state = NULL;
3081 /* Finally merge the cgraph according to the decl merging decisions. */
3082 timevar_push (TV_IPA_LTO_CGRAPH_MERGE);
3083 if (cgraph_dump_file)
3085 fprintf (cgraph_dump_file, "Before merging:\n");
3086 symtab_node::dump_table (cgraph_dump_file);
3088 lto_symtab_merge_symbols ();
3089 /* Removal of unreacable symbols is needed to make verify_symtab to pass;
3090 we are still having duplicated comdat groups containing local statics.
3091 We could also just remove them while merging. */
3092 symtab_remove_unreachable_nodes (false, dump_file);
3093 ggc_collect ();
3094 cgraph_state = CGRAPH_STATE_IPA_SSA;
3096 timevar_pop (TV_IPA_LTO_CGRAPH_MERGE);
3098 /* Indicate that the cgraph is built and ready. */
3099 cgraph_function_flags_ready = true;
3101 ggc_free (all_file_decl_data);
3102 all_file_decl_data = NULL;
3106 /* Materialize all the bodies for all the nodes in the callgraph. */
3108 static void
3109 materialize_cgraph (void)
3111 struct cgraph_node *node;
3112 timevar_id_t lto_timer;
3114 if (!quiet_flag)
3115 fprintf (stderr,
3116 flag_wpa ? "Materializing decls:" : "Reading function bodies:");
3119 FOR_EACH_FUNCTION (node)
3121 if (node->lto_file_data)
3123 lto_materialize_function (node);
3124 lto_stats.num_input_cgraph_nodes++;
3129 /* Start the appropriate timer depending on the mode that we are
3130 operating in. */
3131 lto_timer = (flag_wpa) ? TV_WHOPR_WPA
3132 : (flag_ltrans) ? TV_WHOPR_LTRANS
3133 : TV_LTO;
3134 timevar_push (lto_timer);
3136 current_function_decl = NULL;
3137 set_cfun (NULL);
3139 if (!quiet_flag)
3140 fprintf (stderr, "\n");
3142 timevar_pop (lto_timer);
3146 /* Show various memory usage statistics related to LTO. */
3147 static void
3148 print_lto_report_1 (void)
3150 const char *pfx = (flag_lto) ? "LTO" : (flag_wpa) ? "WPA" : "LTRANS";
3151 fprintf (stderr, "%s statistics\n", pfx);
3153 fprintf (stderr, "[%s] read %lu SCCs of average size %f\n",
3154 pfx, num_sccs_read, total_scc_size / (double)num_sccs_read);
3155 fprintf (stderr, "[%s] %lu tree bodies read in total\n", pfx, total_scc_size);
3156 if (flag_wpa && tree_scc_hash)
3158 fprintf (stderr, "[%s] tree SCC table: size %ld, %ld elements, "
3159 "collision ratio: %f\n", pfx,
3160 (long) tree_scc_hash->size (),
3161 (long) tree_scc_hash->elements (),
3162 tree_scc_hash->collisions ());
3163 hash_table<tree_scc_hasher>::iterator hiter;
3164 tree_scc *scc, *max_scc = NULL;
3165 unsigned max_length = 0;
3166 FOR_EACH_HASH_TABLE_ELEMENT (*tree_scc_hash, scc, x, hiter)
3168 unsigned length = 0;
3169 tree_scc *s = scc;
3170 for (; s; s = s->next)
3171 length++;
3172 if (length > max_length)
3174 max_length = length;
3175 max_scc = scc;
3178 fprintf (stderr, "[%s] tree SCC max chain length %u (size %u)\n",
3179 pfx, max_length, max_scc->len);
3180 fprintf (stderr, "[%s] Compared %lu SCCs, %lu collisions (%f)\n", pfx,
3181 num_scc_compares, num_scc_compare_collisions,
3182 num_scc_compare_collisions / (double) num_scc_compares);
3183 fprintf (stderr, "[%s] Merged %lu SCCs\n", pfx, num_sccs_merged);
3184 fprintf (stderr, "[%s] Merged %lu tree bodies\n", pfx,
3185 total_scc_size_merged);
3186 fprintf (stderr, "[%s] Merged %lu types\n", pfx, num_merged_types);
3187 fprintf (stderr, "[%s] %lu types prevailed (%lu associated trees)\n",
3188 pfx, num_prevailing_types, num_type_scc_trees);
3189 fprintf (stderr, "[%s] GIMPLE canonical type table: size %ld, "
3190 "%ld elements, %ld searches, %ld collisions (ratio: %f)\n", pfx,
3191 (long) htab_size (gimple_canonical_types),
3192 (long) htab_elements (gimple_canonical_types),
3193 (long) gimple_canonical_types->searches,
3194 (long) gimple_canonical_types->collisions,
3195 htab_collisions (gimple_canonical_types));
3196 fprintf (stderr, "[%s] GIMPLE canonical type pointer-map: "
3197 "%lu elements, %ld searches\n", pfx,
3198 num_canonical_type_hash_entries,
3199 num_canonical_type_hash_queries);
3202 print_lto_report (pfx);
3205 /* Perform whole program analysis (WPA) on the callgraph and write out the
3206 optimization plan. */
3208 static void
3209 do_whole_program_analysis (void)
3211 symtab_node *node;
3213 lto_parallelism = 1;
3215 /* TODO: jobserver communicatoin is not supported, yet. */
3216 if (!strcmp (flag_wpa, "jobserver"))
3217 lto_parallelism = -1;
3218 else
3220 lto_parallelism = atoi (flag_wpa);
3221 if (lto_parallelism <= 0)
3222 lto_parallelism = 0;
3225 timevar_start (TV_PHASE_OPT_GEN);
3227 /* Note that since we are in WPA mode, materialize_cgraph will not
3228 actually read in all the function bodies. It only materializes
3229 the decls and cgraph nodes so that analysis can be performed. */
3230 materialize_cgraph ();
3232 /* Reading in the cgraph uses different timers, start timing WPA now. */
3233 timevar_push (TV_WHOPR_WPA);
3235 if (pre_ipa_mem_report)
3237 fprintf (stderr, "Memory consumption before IPA\n");
3238 dump_memory_report (false);
3241 cgraph_function_flags_ready = true;
3243 if (cgraph_dump_file)
3244 symtab_node::dump_table (cgraph_dump_file);
3245 bitmap_obstack_initialize (NULL);
3246 cgraph_state = CGRAPH_STATE_IPA_SSA;
3248 execute_ipa_pass_list (g->get_passes ()->all_regular_ipa_passes);
3249 symtab_remove_unreachable_nodes (false, dump_file);
3251 if (cgraph_dump_file)
3253 fprintf (cgraph_dump_file, "Optimized ");
3254 symtab_node::dump_table (cgraph_dump_file);
3256 #ifdef ENABLE_CHECKING
3257 symtab_node::verify_symtab_nodes ();
3258 #endif
3259 bitmap_obstack_release (NULL);
3261 /* We are about to launch the final LTRANS phase, stop the WPA timer. */
3262 timevar_pop (TV_WHOPR_WPA);
3264 timevar_push (TV_WHOPR_PARTITIONING);
3265 if (flag_lto_partition == LTO_PARTITION_1TO1)
3266 lto_1_to_1_map ();
3267 else if (flag_lto_partition == LTO_PARTITION_MAX)
3268 lto_max_map ();
3269 else if (flag_lto_partition == LTO_PARTITION_ONE)
3270 lto_balanced_map (1);
3271 else if (flag_lto_partition == LTO_PARTITION_BALANCED)
3272 lto_balanced_map (PARAM_VALUE (PARAM_LTO_PARTITIONS));
3273 else
3274 gcc_unreachable ();
3276 /* Inline summaries are needed for balanced partitioning. Free them now so
3277 the memory can be used for streamer caches. */
3278 inline_free_summary ();
3280 /* AUX pointers are used by partitioning code to bookkeep number of
3281 partitions symbol is in. This is no longer needed. */
3282 FOR_EACH_SYMBOL (node)
3283 node->aux = NULL;
3285 lto_stats.num_cgraph_partitions += ltrans_partitions.length ();
3287 /* Find out statics that need to be promoted
3288 to globals with hidden visibility because they are accessed from multiple
3289 partitions. */
3290 lto_promote_cross_file_statics ();
3291 timevar_pop (TV_WHOPR_PARTITIONING);
3293 timevar_stop (TV_PHASE_OPT_GEN);
3295 /* Collect a last time - in lto_wpa_write_files we may end up forking
3296 with the idea that this doesn't increase memory usage. So we
3297 absoultely do not want to collect after that. */
3298 ggc_collect ();
3300 timevar_start (TV_PHASE_STREAM_OUT);
3301 if (!quiet_flag)
3303 fprintf (stderr, "\nStreaming out");
3304 fflush (stderr);
3306 lto_wpa_write_files ();
3307 if (!quiet_flag)
3308 fprintf (stderr, "\n");
3309 timevar_stop (TV_PHASE_STREAM_OUT);
3311 if (post_ipa_mem_report)
3313 fprintf (stderr, "Memory consumption after IPA\n");
3314 dump_memory_report (false);
3317 /* Show the LTO report before launching LTRANS. */
3318 if (flag_lto_report || (flag_wpa && flag_lto_report_wpa))
3319 print_lto_report_1 ();
3320 if (mem_report_wpa)
3321 dump_memory_report (true);
3325 static GTY(()) tree lto_eh_personality_decl;
3327 /* Return the LTO personality function decl. */
3329 tree
3330 lto_eh_personality (void)
3332 if (!lto_eh_personality_decl)
3334 /* Use the first personality DECL for our personality if we don't
3335 support multiple ones. This ensures that we don't artificially
3336 create the need for them in a single-language program. */
3337 if (first_personality_decl && !dwarf2out_do_cfi_asm ())
3338 lto_eh_personality_decl = first_personality_decl;
3339 else
3340 lto_eh_personality_decl = lhd_gcc_personality ();
3343 return lto_eh_personality_decl;
3346 /* Set the process name based on the LTO mode. */
3348 static void
3349 lto_process_name (void)
3351 if (flag_lto)
3352 setproctitle ("lto1-lto");
3353 if (flag_wpa)
3354 setproctitle ("lto1-wpa");
3355 if (flag_ltrans)
3356 setproctitle ("lto1-ltrans");
3360 /* Initialize the LTO front end. */
3362 static void
3363 lto_init (void)
3365 lto_process_name ();
3366 lto_streamer_hooks_init ();
3367 lto_reader_init ();
3368 lto_set_in_hooks (NULL, get_section_data, free_section_data);
3369 memset (&lto_stats, 0, sizeof (lto_stats));
3370 bitmap_obstack_initialize (NULL);
3371 gimple_register_cfg_hooks ();
3375 /* Main entry point for the GIMPLE front end. This front end has
3376 three main personalities:
3378 - LTO (-flto). All the object files on the command line are
3379 loaded in memory and processed as a single translation unit.
3380 This is the traditional link-time optimization behavior.
3382 - WPA (-fwpa). Only the callgraph and summary information for
3383 files in the command file are loaded. A single callgraph
3384 (without function bodies) is instantiated for the whole set of
3385 files. IPA passes are only allowed to analyze the call graph
3386 and make transformation decisions. The callgraph is
3387 partitioned, each partition is written to a new object file
3388 together with the transformation decisions.
3390 - LTRANS (-fltrans). Similar to -flto but it prevents the IPA
3391 summary files from running again. Since WPA computed summary
3392 information and decided what transformations to apply, LTRANS
3393 simply applies them. */
3395 void
3396 lto_main (void)
3398 /* LTO is called as a front end, even though it is not a front end.
3399 Because it is called as a front end, TV_PHASE_PARSING and
3400 TV_PARSE_GLOBAL are active, and we need to turn them off while
3401 doing LTO. Later we turn them back on so they are active up in
3402 toplev.c. */
3403 timevar_pop (TV_PARSE_GLOBAL);
3404 timevar_stop (TV_PHASE_PARSING);
3406 timevar_start (TV_PHASE_SETUP);
3408 /* Initialize the LTO front end. */
3409 lto_init ();
3411 timevar_stop (TV_PHASE_SETUP);
3412 timevar_start (TV_PHASE_STREAM_IN);
3414 /* Read all the symbols and call graph from all the files in the
3415 command line. */
3416 read_cgraph_and_symbols (num_in_fnames, in_fnames);
3418 timevar_stop (TV_PHASE_STREAM_IN);
3420 if (!seen_error ())
3422 /* If WPA is enabled analyze the whole call graph and create an
3423 optimization plan. Otherwise, read in all the function
3424 bodies and continue with optimization. */
3425 if (flag_wpa)
3426 do_whole_program_analysis ();
3427 else
3429 timevar_start (TV_PHASE_OPT_GEN);
3431 materialize_cgraph ();
3432 if (!flag_ltrans)
3433 lto_promote_statics_nonwpa ();
3435 /* Let the middle end know that we have read and merged all of
3436 the input files. */
3437 compile ();
3439 timevar_stop (TV_PHASE_OPT_GEN);
3441 /* FIXME lto, if the processes spawned by WPA fail, we miss
3442 the chance to print WPA's report, so WPA will call
3443 print_lto_report before launching LTRANS. If LTRANS was
3444 launched directly by the driver we would not need to do
3445 this. */
3446 if (flag_lto_report || (flag_wpa && flag_lto_report_wpa))
3447 print_lto_report_1 ();
3451 /* Here we make LTO pretend to be a parser. */
3452 timevar_start (TV_PHASE_PARSING);
3453 timevar_push (TV_PARSE_GLOBAL);
3456 #include "gt-lto-lto.h"