1 /* Top-level LTO routines.
2 Copyright (C) 2009-2015 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
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
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/>. */
23 #include "coretypes.h"
29 #include "double-int.h"
37 #include "fixed-value.h"
39 #include "fold-const.h"
40 #include "stor-layout.h"
41 #include "diagnostic-core.h"
44 #include "basic-block.h"
47 #include "plugin-api.h"
48 #include "hard-reg-set.h"
53 #include "tree-ssa-operands.h"
54 #include "tree-pass.h"
55 #include "langhooks.h"
58 #include "alloc-pool.h"
59 #include "symbol-summary.h"
63 #include "tree-ssa-alias.h"
64 #include "internal-fn.h"
65 #include "gimple-expr.h"
69 #include "lto-streamer.h"
70 #include "lto-section-names.h"
71 #include "tree-streamer.h"
72 #include "splay-tree.h"
73 #include "lto-partition.h"
74 #include "data-streamer.h"
76 #include "pass_manager.h"
77 #include "ipa-inline.h"
79 #include "ipa-utils.h"
80 #include "gomp-constants.h"
83 /* Number of parallel tasks to run, -1 if we want to use GNU Make jobserver. */
84 static int lto_parallelism
;
86 static GTY(()) tree first_personality_decl
;
88 /* Returns a hash code for P. */
91 hash_name (const void *p
)
93 const struct lto_section_slot
*ds
= (const struct lto_section_slot
*) p
;
94 return (hashval_t
) htab_hash_string (ds
->name
);
98 /* Returns nonzero if P1 and P2 are equal. */
101 eq_name (const void *p1
, const void *p2
)
103 const struct lto_section_slot
*s1
=
104 (const struct lto_section_slot
*) p1
;
105 const struct lto_section_slot
*s2
=
106 (const struct lto_section_slot
*) p2
;
108 return strcmp (s1
->name
, s2
->name
) == 0;
111 /* Free lto_section_slot */
114 free_with_string (void *arg
)
116 struct lto_section_slot
*s
= (struct lto_section_slot
*)arg
;
118 free (CONST_CAST (char *, s
->name
));
122 /* Create section hash table */
125 lto_obj_create_section_hash_table (void)
127 return htab_create (37, hash_name
, eq_name
, free_with_string
);
130 /* Delete an allocated integer KEY in the splay tree. */
133 lto_splay_tree_delete_id (splay_tree_key key
)
138 /* Compare splay tree node ids A and B. */
141 lto_splay_tree_compare_ids (splay_tree_key a
, splay_tree_key b
)
143 unsigned HOST_WIDE_INT ai
;
144 unsigned HOST_WIDE_INT bi
;
146 ai
= *(unsigned HOST_WIDE_INT
*) a
;
147 bi
= *(unsigned HOST_WIDE_INT
*) b
;
156 /* Look up splay tree node by ID in splay tree T. */
158 static splay_tree_node
159 lto_splay_tree_lookup (splay_tree t
, unsigned HOST_WIDE_INT id
)
161 return splay_tree_lookup (t
, (splay_tree_key
) &id
);
164 /* Check if KEY has ID. */
167 lto_splay_tree_id_equal_p (splay_tree_key key
, unsigned HOST_WIDE_INT id
)
169 return *(unsigned HOST_WIDE_INT
*) key
== id
;
172 /* Insert a splay tree node into tree T with ID as key and FILE_DATA as value.
173 The ID is allocated separately because we need HOST_WIDE_INTs which may
174 be wider than a splay_tree_key. */
177 lto_splay_tree_insert (splay_tree t
, unsigned HOST_WIDE_INT id
,
178 struct lto_file_decl_data
*file_data
)
180 unsigned HOST_WIDE_INT
*idp
= XCNEW (unsigned HOST_WIDE_INT
);
182 splay_tree_insert (t
, (splay_tree_key
) idp
, (splay_tree_value
) file_data
);
185 /* Create a splay tree. */
188 lto_splay_tree_new (void)
190 return splay_tree_new (lto_splay_tree_compare_ids
,
191 lto_splay_tree_delete_id
,
195 /* Return true when NODE has a clone that is analyzed (i.e. we need
196 to load its body even if the node itself is not needed). */
199 has_analyzed_clone_p (struct cgraph_node
*node
)
201 struct cgraph_node
*orig
= node
;
210 else if (node
->next_sibling_clone
)
211 node
= node
->next_sibling_clone
;
214 while (node
!= orig
&& !node
->next_sibling_clone
)
215 node
= node
->clone_of
;
217 node
= node
->next_sibling_clone
;
223 /* Read the function body for the function associated with NODE. */
226 lto_materialize_function (struct cgraph_node
*node
)
231 /* Read in functions with body (analyzed nodes)
232 and also functions that are needed to produce virtual clones. */
233 if ((node
->has_gimple_body_p () && node
->analyzed
)
234 || node
->used_as_abstract_origin
235 || has_analyzed_clone_p (node
))
237 /* Clones don't need to be read. */
240 if (DECL_FUNCTION_PERSONALITY (decl
) && !first_personality_decl
)
241 first_personality_decl
= DECL_FUNCTION_PERSONALITY (decl
);
244 /* Let the middle end know about the function. */
245 rest_of_decl_compilation (decl
, 1, 0);
249 /* Decode the content of memory pointed to by DATA in the in decl
250 state object STATE. DATA_IN points to a data_in structure for
251 decoding. Return the address after the decoded object in the
254 static const uint32_t *
255 lto_read_in_decl_state (struct data_in
*data_in
, const uint32_t *data
,
256 struct lto_in_decl_state
*state
)
263 decl
= streamer_tree_cache_get_tree (data_in
->reader_cache
, ix
);
264 if (!VAR_OR_FUNCTION_DECL_P (decl
))
266 gcc_assert (decl
== void_type_node
);
269 state
->fn_decl
= decl
;
271 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
273 uint32_t size
= *data
++;
274 vec
<tree
, va_gc
> *decls
= NULL
;
275 vec_alloc (decls
, size
);
277 for (j
= 0; j
< size
; j
++)
278 vec_safe_push (decls
,
279 streamer_tree_cache_get_tree (data_in
->reader_cache
,
282 state
->streams
[i
] = decls
;
290 /* Global canonical type table. */
291 static htab_t gimple_canonical_types
;
292 static hash_map
<const_tree
, hashval_t
> *canonical_type_hash_cache
;
293 static unsigned long num_canonical_type_hash_entries
;
294 static unsigned long num_canonical_type_hash_queries
;
296 static void iterative_hash_canonical_type (tree type
, inchash::hash
&hstate
);
297 static hashval_t
gimple_canonical_type_hash (const void *p
);
298 static void gimple_register_canonical_type_1 (tree t
, hashval_t hash
);
300 /* Returning a hash value for gimple type TYPE.
302 The hash value returned is equal for types considered compatible
303 by gimple_canonical_types_compatible_p. */
306 hash_canonical_type (tree type
)
308 inchash::hash hstate
;
310 /* Combine a few common features of types so that types are grouped into
311 smaller sets; when searching for existing matching types to merge,
312 only existing types having the same features as the new type will be
314 hstate
.add_int (TREE_CODE (type
));
315 hstate
.add_int (TYPE_MODE (type
));
317 /* Incorporate common features of numerical types. */
318 if (INTEGRAL_TYPE_P (type
)
319 || SCALAR_FLOAT_TYPE_P (type
)
320 || FIXED_POINT_TYPE_P (type
)
321 || TREE_CODE (type
) == OFFSET_TYPE
322 || POINTER_TYPE_P (type
))
324 hstate
.add_int (TYPE_UNSIGNED (type
));
325 hstate
.add_int (TYPE_PRECISION (type
));
328 if (VECTOR_TYPE_P (type
))
330 hstate
.add_int (TYPE_VECTOR_SUBPARTS (type
));
331 hstate
.add_int (TYPE_UNSIGNED (type
));
334 if (TREE_CODE (type
) == COMPLEX_TYPE
)
335 hstate
.add_int (TYPE_UNSIGNED (type
));
337 /* For pointer and reference types, fold in information about the type
338 pointed to but do not recurse to the pointed-to type. */
339 if (POINTER_TYPE_P (type
))
341 hstate
.add_int (TYPE_ADDR_SPACE (TREE_TYPE (type
)));
342 hstate
.add_int (TREE_CODE (TREE_TYPE (type
)));
345 /* For integer types hash only the string flag. */
346 if (TREE_CODE (type
) == INTEGER_TYPE
)
347 hstate
.add_int (TYPE_STRING_FLAG (type
));
349 /* For array types hash the domain bounds and the string flag. */
350 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
352 hstate
.add_int (TYPE_STRING_FLAG (type
));
353 /* OMP lowering can introduce error_mark_node in place of
354 random local decls in types. */
355 if (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)) != error_mark_node
)
356 inchash::add_expr (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)), hstate
);
357 if (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != error_mark_node
)
358 inchash::add_expr (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)), hstate
);
361 /* Recurse for aggregates with a single element type. */
362 if (TREE_CODE (type
) == ARRAY_TYPE
363 || TREE_CODE (type
) == COMPLEX_TYPE
364 || TREE_CODE (type
) == VECTOR_TYPE
)
365 iterative_hash_canonical_type (TREE_TYPE (type
), hstate
);
367 /* Incorporate function return and argument types. */
368 if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
373 /* For method types also incorporate their parent class. */
374 if (TREE_CODE (type
) == METHOD_TYPE
)
375 iterative_hash_canonical_type (TYPE_METHOD_BASETYPE (type
), hstate
);
377 iterative_hash_canonical_type (TREE_TYPE (type
), hstate
);
379 for (p
= TYPE_ARG_TYPES (type
), na
= 0; p
; p
= TREE_CHAIN (p
))
381 iterative_hash_canonical_type (TREE_VALUE (p
), hstate
);
388 if (RECORD_OR_UNION_TYPE_P (type
))
393 for (f
= TYPE_FIELDS (type
), nf
= 0; f
; f
= TREE_CHAIN (f
))
394 if (TREE_CODE (f
) == FIELD_DECL
)
396 iterative_hash_canonical_type (TREE_TYPE (f
), hstate
);
406 /* Returning a hash value for gimple type TYPE combined with VAL. */
409 iterative_hash_canonical_type (tree type
, inchash::hash
&hstate
)
412 /* An already processed type. */
413 if (TYPE_CANONICAL (type
))
415 type
= TYPE_CANONICAL (type
);
416 v
= gimple_canonical_type_hash (type
);
420 /* Canonical types should not be able to form SCCs by design, this
421 recursion is just because we do not register canonical types in
422 optimal order. To avoid quadratic behavior also register the
424 v
= hash_canonical_type (type
);
425 gimple_register_canonical_type_1 (type
, v
);
430 /* Returns the hash for a canonical type P. */
433 gimple_canonical_type_hash (const void *p
)
435 num_canonical_type_hash_queries
++;
436 hashval_t
*slot
= canonical_type_hash_cache
->get ((const_tree
) p
);
437 gcc_assert (slot
!= NULL
);
442 /* The TYPE_CANONICAL merging machinery. It should closely resemble
443 the middle-end types_compatible_p function. It needs to avoid
444 claiming types are different for types that should be treated
445 the same with respect to TBAA. Canonical types are also used
446 for IL consistency checks via the useless_type_conversion_p
447 predicate which does not handle all type kinds itself but falls
448 back to pointer-comparison of TYPE_CANONICAL for aggregates
451 /* Return true iff T1 and T2 are structurally identical for what
452 TBAA is concerned. */
455 gimple_canonical_types_compatible_p (tree t1
, tree t2
)
457 /* Before starting to set up the SCC machinery handle simple cases. */
459 /* Check first for the obvious case of pointer identity. */
463 /* Check that we have two types to compare. */
464 if (t1
== NULL_TREE
|| t2
== NULL_TREE
)
467 /* If the types have been previously registered and found equal
469 if (TYPE_CANONICAL (t1
)
470 && TYPE_CANONICAL (t1
) == TYPE_CANONICAL (t2
))
473 /* Can't be the same type if the types don't have the same code. */
474 if (TREE_CODE (t1
) != TREE_CODE (t2
))
477 /* Qualifiers do not matter for canonical type comparison purposes. */
479 /* Void types and nullptr types are always the same. */
480 if (TREE_CODE (t1
) == VOID_TYPE
481 || TREE_CODE (t1
) == NULLPTR_TYPE
)
484 /* Can't be the same type if they have different mode. */
485 if (TYPE_MODE (t1
) != TYPE_MODE (t2
))
488 /* Non-aggregate types can be handled cheaply. */
489 if (INTEGRAL_TYPE_P (t1
)
490 || SCALAR_FLOAT_TYPE_P (t1
)
491 || FIXED_POINT_TYPE_P (t1
)
492 || TREE_CODE (t1
) == VECTOR_TYPE
493 || TREE_CODE (t1
) == COMPLEX_TYPE
494 || TREE_CODE (t1
) == OFFSET_TYPE
495 || POINTER_TYPE_P (t1
))
497 /* Can't be the same type if they have different sign or precision. */
498 if (TYPE_PRECISION (t1
) != TYPE_PRECISION (t2
)
499 || TYPE_UNSIGNED (t1
) != TYPE_UNSIGNED (t2
))
502 if (TREE_CODE (t1
) == INTEGER_TYPE
503 && TYPE_STRING_FLAG (t1
) != TYPE_STRING_FLAG (t2
))
506 /* For canonical type comparisons we do not want to build SCCs
507 so we cannot compare pointed-to types. But we can, for now,
508 require the same pointed-to type kind and match what
509 useless_type_conversion_p would do. */
510 if (POINTER_TYPE_P (t1
))
512 if (TYPE_ADDR_SPACE (TREE_TYPE (t1
))
513 != TYPE_ADDR_SPACE (TREE_TYPE (t2
)))
516 if (TREE_CODE (TREE_TYPE (t1
)) != TREE_CODE (TREE_TYPE (t2
)))
520 /* Tail-recurse to components. */
521 if (TREE_CODE (t1
) == VECTOR_TYPE
522 || TREE_CODE (t1
) == COMPLEX_TYPE
)
523 return gimple_canonical_types_compatible_p (TREE_TYPE (t1
),
529 /* Do type-specific comparisons. */
530 switch (TREE_CODE (t1
))
533 /* Array types are the same if the element types are the same and
534 the number of elements are the same. */
535 if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
536 || TYPE_STRING_FLAG (t1
) != TYPE_STRING_FLAG (t2
)
537 || TYPE_NONALIASED_COMPONENT (t1
) != TYPE_NONALIASED_COMPONENT (t2
))
541 tree i1
= TYPE_DOMAIN (t1
);
542 tree i2
= TYPE_DOMAIN (t2
);
544 /* For an incomplete external array, the type domain can be
545 NULL_TREE. Check this condition also. */
546 if (i1
== NULL_TREE
&& i2
== NULL_TREE
)
548 else if (i1
== NULL_TREE
|| i2
== NULL_TREE
)
552 tree min1
= TYPE_MIN_VALUE (i1
);
553 tree min2
= TYPE_MIN_VALUE (i2
);
554 tree max1
= TYPE_MAX_VALUE (i1
);
555 tree max2
= TYPE_MAX_VALUE (i2
);
557 /* The minimum/maximum values have to be the same. */
560 && ((TREE_CODE (min1
) == PLACEHOLDER_EXPR
561 && TREE_CODE (min2
) == PLACEHOLDER_EXPR
)
562 || operand_equal_p (min1
, min2
, 0))))
565 && ((TREE_CODE (max1
) == PLACEHOLDER_EXPR
566 && TREE_CODE (max2
) == PLACEHOLDER_EXPR
)
567 || operand_equal_p (max1
, max2
, 0)))))
576 /* Function types are the same if the return type and arguments types
578 if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
581 if (!comp_type_attributes (t1
, t2
))
584 if (TYPE_ARG_TYPES (t1
) == TYPE_ARG_TYPES (t2
))
590 for (parms1
= TYPE_ARG_TYPES (t1
), parms2
= TYPE_ARG_TYPES (t2
);
592 parms1
= TREE_CHAIN (parms1
), parms2
= TREE_CHAIN (parms2
))
594 if (!gimple_canonical_types_compatible_p
595 (TREE_VALUE (parms1
), TREE_VALUE (parms2
)))
599 if (parms1
|| parms2
)
607 case QUAL_UNION_TYPE
:
611 /* For aggregate types, all the fields must be the same. */
612 for (f1
= TYPE_FIELDS (t1
), f2
= TYPE_FIELDS (t2
);
614 f1
= TREE_CHAIN (f1
), f2
= TREE_CHAIN (f2
))
616 /* Skip non-fields. */
617 while (f1
&& TREE_CODE (f1
) != FIELD_DECL
)
618 f1
= TREE_CHAIN (f1
);
619 while (f2
&& TREE_CODE (f2
) != FIELD_DECL
)
620 f2
= TREE_CHAIN (f2
);
623 /* The fields must have the same name, offset and type. */
624 if (DECL_NONADDRESSABLE_P (f1
) != DECL_NONADDRESSABLE_P (f2
)
625 || !gimple_compare_field_offset (f1
, f2
)
626 || !gimple_canonical_types_compatible_p
627 (TREE_TYPE (f1
), TREE_TYPE (f2
)))
631 /* If one aggregate has more fields than the other, they
645 /* Returns nonzero if P1 and P2 are equal. */
648 gimple_canonical_type_eq (const void *p1
, const void *p2
)
650 const_tree t1
= (const_tree
) p1
;
651 const_tree t2
= (const_tree
) p2
;
652 return gimple_canonical_types_compatible_p (CONST_CAST_TREE (t1
),
653 CONST_CAST_TREE (t2
));
656 /* Main worker for gimple_register_canonical_type. */
659 gimple_register_canonical_type_1 (tree t
, hashval_t hash
)
663 gcc_checking_assert (TYPE_P (t
) && !TYPE_CANONICAL (t
));
665 slot
= htab_find_slot_with_hash (gimple_canonical_types
, t
, hash
, INSERT
);
668 tree new_type
= (tree
)(*slot
);
669 gcc_checking_assert (new_type
!= t
);
670 TYPE_CANONICAL (t
) = new_type
;
674 TYPE_CANONICAL (t
) = t
;
676 /* Cache the just computed hash value. */
677 num_canonical_type_hash_entries
++;
678 bool existed_p
= canonical_type_hash_cache
->put (t
, hash
);
679 gcc_assert (!existed_p
);
683 /* Register type T in the global type table gimple_types and set
684 TYPE_CANONICAL of T accordingly.
685 This is used by LTO to merge structurally equivalent types for
686 type-based aliasing purposes across different TUs and languages.
688 ??? This merging does not exactly match how the tree.c middle-end
689 functions will assign TYPE_CANONICAL when new types are created
690 during optimization (which at least happens for pointer and array
694 gimple_register_canonical_type (tree t
)
696 if (TYPE_CANONICAL (t
))
699 gimple_register_canonical_type_1 (t
, hash_canonical_type (t
));
702 /* Re-compute TYPE_CANONICAL for NODE and related types. */
705 lto_register_canonical_types (tree node
, bool first_p
)
712 TYPE_CANONICAL (node
) = NULL_TREE
;
714 if (POINTER_TYPE_P (node
)
715 || TREE_CODE (node
) == COMPLEX_TYPE
716 || TREE_CODE (node
) == ARRAY_TYPE
)
717 lto_register_canonical_types (TREE_TYPE (node
), first_p
);
720 gimple_register_canonical_type (node
);
724 /* Remember trees that contains references to declarations. */
725 static GTY(()) vec
<tree
, va_gc
> *tree_with_vars
;
727 #define CHECK_VAR(tt) \
730 if ((tt) && VAR_OR_FUNCTION_DECL_P (tt) \
731 && (TREE_PUBLIC (tt) || DECL_EXTERNAL (tt))) \
735 #define CHECK_NO_VAR(tt) \
736 gcc_checking_assert (!(tt) || !VAR_OR_FUNCTION_DECL_P (tt))
738 /* Check presence of pointers to decls in fields of a tree_typed T. */
741 mentions_vars_p_typed (tree t
)
743 CHECK_NO_VAR (TREE_TYPE (t
));
747 /* Check presence of pointers to decls in fields of a tree_common T. */
750 mentions_vars_p_common (tree t
)
752 if (mentions_vars_p_typed (t
))
754 CHECK_NO_VAR (TREE_CHAIN (t
));
758 /* Check presence of pointers to decls in fields of a decl_minimal T. */
761 mentions_vars_p_decl_minimal (tree t
)
763 if (mentions_vars_p_common (t
))
765 CHECK_NO_VAR (DECL_NAME (t
));
766 CHECK_VAR (DECL_CONTEXT (t
));
770 /* Check presence of pointers to decls in fields of a decl_common T. */
773 mentions_vars_p_decl_common (tree t
)
775 if (mentions_vars_p_decl_minimal (t
))
777 CHECK_VAR (DECL_SIZE (t
));
778 CHECK_VAR (DECL_SIZE_UNIT (t
));
779 CHECK_VAR (DECL_INITIAL (t
));
780 CHECK_NO_VAR (DECL_ATTRIBUTES (t
));
781 CHECK_VAR (DECL_ABSTRACT_ORIGIN (t
));
785 /* Check presence of pointers to decls in fields of a decl_with_vis T. */
788 mentions_vars_p_decl_with_vis (tree t
)
790 if (mentions_vars_p_decl_common (t
))
793 /* Accessor macro has side-effects, use field-name here. */
794 CHECK_NO_VAR (t
->decl_with_vis
.assembler_name
);
798 /* Check presence of pointers to decls in fields of a decl_non_common T. */
801 mentions_vars_p_decl_non_common (tree t
)
803 if (mentions_vars_p_decl_with_vis (t
))
805 CHECK_NO_VAR (DECL_RESULT_FLD (t
));
809 /* Check presence of pointers to decls in fields of a decl_non_common T. */
812 mentions_vars_p_function (tree t
)
814 if (mentions_vars_p_decl_non_common (t
))
816 CHECK_NO_VAR (DECL_ARGUMENTS (t
));
817 CHECK_NO_VAR (DECL_VINDEX (t
));
818 CHECK_VAR (DECL_FUNCTION_PERSONALITY (t
));
822 /* Check presence of pointers to decls in fields of a field_decl T. */
825 mentions_vars_p_field_decl (tree t
)
827 if (mentions_vars_p_decl_common (t
))
829 CHECK_VAR (DECL_FIELD_OFFSET (t
));
830 CHECK_NO_VAR (DECL_BIT_FIELD_TYPE (t
));
831 CHECK_NO_VAR (DECL_QUALIFIER (t
));
832 CHECK_NO_VAR (DECL_FIELD_BIT_OFFSET (t
));
833 CHECK_NO_VAR (DECL_FCONTEXT (t
));
837 /* Check presence of pointers to decls in fields of a type T. */
840 mentions_vars_p_type (tree t
)
842 if (mentions_vars_p_common (t
))
844 CHECK_NO_VAR (TYPE_CACHED_VALUES (t
));
845 CHECK_VAR (TYPE_SIZE (t
));
846 CHECK_VAR (TYPE_SIZE_UNIT (t
));
847 CHECK_NO_VAR (TYPE_ATTRIBUTES (t
));
848 CHECK_NO_VAR (TYPE_NAME (t
));
850 CHECK_VAR (TYPE_MINVAL (t
));
851 CHECK_VAR (TYPE_MAXVAL (t
));
853 /* Accessor is for derived node types only. */
854 CHECK_NO_VAR (t
->type_non_common
.binfo
);
856 CHECK_VAR (TYPE_CONTEXT (t
));
857 CHECK_NO_VAR (TYPE_CANONICAL (t
));
858 CHECK_NO_VAR (TYPE_MAIN_VARIANT (t
));
859 CHECK_NO_VAR (TYPE_NEXT_VARIANT (t
));
863 /* Check presence of pointers to decls in fields of a BINFO T. */
866 mentions_vars_p_binfo (tree t
)
868 unsigned HOST_WIDE_INT i
, n
;
870 if (mentions_vars_p_common (t
))
872 CHECK_VAR (BINFO_VTABLE (t
));
873 CHECK_NO_VAR (BINFO_OFFSET (t
));
874 CHECK_NO_VAR (BINFO_VIRTUALS (t
));
875 CHECK_NO_VAR (BINFO_VPTR_FIELD (t
));
876 n
= vec_safe_length (BINFO_BASE_ACCESSES (t
));
877 for (i
= 0; i
< n
; i
++)
878 CHECK_NO_VAR (BINFO_BASE_ACCESS (t
, i
));
879 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
880 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
881 n
= BINFO_N_BASE_BINFOS (t
);
882 for (i
= 0; i
< n
; i
++)
883 CHECK_NO_VAR (BINFO_BASE_BINFO (t
, i
));
887 /* Check presence of pointers to decls in fields of a CONSTRUCTOR T. */
890 mentions_vars_p_constructor (tree t
)
892 unsigned HOST_WIDE_INT idx
;
895 if (mentions_vars_p_typed (t
))
898 for (idx
= 0; vec_safe_iterate (CONSTRUCTOR_ELTS (t
), idx
, &ce
); idx
++)
900 CHECK_NO_VAR (ce
->index
);
901 CHECK_VAR (ce
->value
);
906 /* Check presence of pointers to decls in fields of an expression tree T. */
909 mentions_vars_p_expr (tree t
)
912 if (mentions_vars_p_typed (t
))
914 for (i
= TREE_OPERAND_LENGTH (t
) - 1; i
>= 0; --i
)
915 CHECK_VAR (TREE_OPERAND (t
, i
));
919 /* Check presence of pointers to decls in fields of an OMP_CLAUSE T. */
922 mentions_vars_p_omp_clause (tree t
)
925 if (mentions_vars_p_common (t
))
927 for (i
= omp_clause_num_ops
[OMP_CLAUSE_CODE (t
)] - 1; i
>= 0; --i
)
928 CHECK_VAR (OMP_CLAUSE_OPERAND (t
, i
));
932 /* Check presence of pointers to decls that needs later fixup in T. */
935 mentions_vars_p (tree t
)
937 switch (TREE_CODE (t
))
939 case IDENTIFIER_NODE
:
943 CHECK_VAR (TREE_VALUE (t
));
944 CHECK_VAR (TREE_PURPOSE (t
));
945 CHECK_NO_VAR (TREE_CHAIN (t
));
949 return mentions_vars_p_field_decl (t
);
958 return mentions_vars_p_decl_common (t
);
961 return mentions_vars_p_decl_with_vis (t
);
964 return mentions_vars_p_decl_non_common (t
);
967 return mentions_vars_p_function (t
);
970 return mentions_vars_p_binfo (t
);
972 case PLACEHOLDER_EXPR
:
973 return mentions_vars_p_common (t
);
976 case TRANSLATION_UNIT_DECL
:
977 case OPTIMIZATION_NODE
:
978 case TARGET_OPTION_NODE
:
982 return mentions_vars_p_constructor (t
);
985 return mentions_vars_p_omp_clause (t
);
990 if (mentions_vars_p_type (t
))
995 if (mentions_vars_p_expr (t
))
998 else if (CONSTANT_CLASS_P (t
))
999 CHECK_NO_VAR (TREE_TYPE (t
));
1007 /* Return the resolution for the decl with index INDEX from DATA_IN. */
1009 static enum ld_plugin_symbol_resolution
1010 get_resolution (struct data_in
*data_in
, unsigned index
)
1012 if (data_in
->globals_resolution
.exists ())
1014 ld_plugin_symbol_resolution_t ret
;
1015 /* We can have references to not emitted functions in
1016 DECL_FUNCTION_PERSONALITY at least. So we can and have
1017 to indeed return LDPR_UNKNOWN in some cases. */
1018 if (data_in
->globals_resolution
.length () <= index
)
1019 return LDPR_UNKNOWN
;
1020 ret
= data_in
->globals_resolution
[index
];
1024 /* Delay resolution finding until decl merging. */
1025 return LDPR_UNKNOWN
;
1028 /* We need to record resolutions until symbol table is read. */
1030 register_resolution (struct lto_file_decl_data
*file_data
, tree decl
,
1031 enum ld_plugin_symbol_resolution resolution
)
1033 if (resolution
== LDPR_UNKNOWN
)
1035 if (!file_data
->resolution_map
)
1036 file_data
->resolution_map
1037 = new hash_map
<tree
, ld_plugin_symbol_resolution
>;
1038 file_data
->resolution_map
->put (decl
, resolution
);
1041 /* Register DECL with the global symbol table and change its
1042 name if necessary to avoid name clashes for static globals across
1046 lto_register_var_decl_in_symtab (struct data_in
*data_in
, tree decl
,
1051 /* Variable has file scope, not local. */
1052 if (!TREE_PUBLIC (decl
)
1053 && !((context
= decl_function_context (decl
))
1054 && auto_var_in_fn_p (decl
, context
)))
1055 rest_of_decl_compilation (decl
, 1, 0);
1057 /* If this variable has already been declared, queue the
1058 declaration for merging. */
1059 if (TREE_PUBLIC (decl
))
1060 register_resolution (data_in
->file_data
,
1061 decl
, get_resolution (data_in
, ix
));
1065 /* Register DECL with the global symbol table and change its
1066 name if necessary to avoid name clashes for static globals across
1067 different files. DATA_IN contains descriptors and tables for the
1071 lto_register_function_decl_in_symtab (struct data_in
*data_in
, tree decl
,
1074 /* If this variable has already been declared, queue the
1075 declaration for merging. */
1076 if (TREE_PUBLIC (decl
) && !DECL_ABSTRACT_P (decl
))
1077 register_resolution (data_in
->file_data
,
1078 decl
, get_resolution (data_in
, ix
));
1082 /* For the type T re-materialize it in the type variant list and
1083 the pointer/reference-to chains. */
1086 lto_fixup_prevailing_type (tree t
)
1088 /* The following re-creates proper variant lists while fixing up
1089 the variant leaders. We do not stream TYPE_NEXT_VARIANT so the
1090 variant list state before fixup is broken. */
1092 /* If we are not our own variant leader link us into our new leaders
1094 if (TYPE_MAIN_VARIANT (t
) != t
)
1096 tree mv
= TYPE_MAIN_VARIANT (t
);
1097 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (mv
);
1098 TYPE_NEXT_VARIANT (mv
) = t
;
1101 /* The following reconstructs the pointer chains
1102 of the new pointed-to type if we are a main variant. We do
1103 not stream those so they are broken before fixup. */
1104 if (TREE_CODE (t
) == POINTER_TYPE
1105 && TYPE_MAIN_VARIANT (t
) == t
)
1107 TYPE_NEXT_PTR_TO (t
) = TYPE_POINTER_TO (TREE_TYPE (t
));
1108 TYPE_POINTER_TO (TREE_TYPE (t
)) = t
;
1110 else if (TREE_CODE (t
) == REFERENCE_TYPE
1111 && TYPE_MAIN_VARIANT (t
) == t
)
1113 TYPE_NEXT_REF_TO (t
) = TYPE_REFERENCE_TO (TREE_TYPE (t
));
1114 TYPE_REFERENCE_TO (TREE_TYPE (t
)) = t
;
1119 /* We keep prevailing tree SCCs in a hashtable with manual collision
1120 handling (in case all hashes compare the same) and keep the colliding
1121 entries in the tree_scc->next chain. */
1126 /* Hash of the whole SCC. */
1128 /* Number of trees in the SCC. */
1130 /* Number of possible entries into the SCC (tree nodes [0..entry_len-1]
1131 which share the same individual tree hash). */
1133 /* The members of the SCC.
1134 We only need to remember the first entry node candidate for prevailing
1135 SCCs (but of course have access to all entries for SCCs we are
1137 ??? For prevailing SCCs we really only need hash and the first
1138 entry candidate, but that's too awkward to implement. */
1142 struct tree_scc_hasher
: typed_noop_remove
<tree_scc
>
1144 typedef tree_scc value_type
;
1145 typedef tree_scc compare_type
;
1146 static inline hashval_t
hash (const value_type
*);
1147 static inline bool equal (const value_type
*, const compare_type
*);
1151 tree_scc_hasher::hash (const value_type
*scc
)
1157 tree_scc_hasher::equal (const value_type
*scc1
, const compare_type
*scc2
)
1159 if (scc1
->hash
!= scc2
->hash
1160 || scc1
->len
!= scc2
->len
1161 || scc1
->entry_len
!= scc2
->entry_len
)
1166 static hash_table
<tree_scc_hasher
> *tree_scc_hash
;
1167 static struct obstack tree_scc_hash_obstack
;
1169 static unsigned long num_merged_types
;
1170 static unsigned long num_prevailing_types
;
1171 static unsigned long num_type_scc_trees
;
1172 static unsigned long total_scc_size
;
1173 static unsigned long num_sccs_read
;
1174 static unsigned long total_scc_size_merged
;
1175 static unsigned long num_sccs_merged
;
1176 static unsigned long num_scc_compares
;
1177 static unsigned long num_scc_compare_collisions
;
1180 /* Compare the two entries T1 and T2 of two SCCs that are possibly equal,
1181 recursing through in-SCC tree edges. Returns true if the SCCs entered
1182 through T1 and T2 are equal and fills in *MAP with the pairs of
1183 SCC entries we visited, starting with (*MAP)[0] = T1 and (*MAP)[1] = T2. */
1186 compare_tree_sccs_1 (tree t1
, tree t2
, tree
**map
)
1188 enum tree_code code
;
1190 /* Mark already visited nodes. */
1191 TREE_ASM_WRITTEN (t2
) = 1;
1193 /* Push the pair onto map. */
1198 /* Compare value-fields. */
1199 #define compare_values(X) \
1201 if (X(t1) != X(t2)) \
1205 compare_values (TREE_CODE
);
1206 code
= TREE_CODE (t1
);
1210 compare_values (TREE_SIDE_EFFECTS
);
1211 compare_values (TREE_CONSTANT
);
1212 compare_values (TREE_READONLY
);
1213 compare_values (TREE_PUBLIC
);
1215 compare_values (TREE_ADDRESSABLE
);
1216 compare_values (TREE_THIS_VOLATILE
);
1218 compare_values (DECL_UNSIGNED
);
1219 else if (TYPE_P (t1
))
1220 compare_values (TYPE_UNSIGNED
);
1222 compare_values (TYPE_ARTIFICIAL
);
1224 compare_values (TREE_NO_WARNING
);
1225 compare_values (TREE_NOTHROW
);
1226 compare_values (TREE_STATIC
);
1227 if (code
!= TREE_BINFO
)
1228 compare_values (TREE_PRIVATE
);
1229 compare_values (TREE_PROTECTED
);
1230 compare_values (TREE_DEPRECATED
);
1233 compare_values (TYPE_SATURATING
);
1234 compare_values (TYPE_ADDR_SPACE
);
1236 else if (code
== SSA_NAME
)
1237 compare_values (SSA_NAME_IS_DEFAULT_DEF
);
1239 if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
1241 if (!wi::eq_p (t1
, t2
))
1245 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
1247 /* ??? No suitable compare routine available. */
1248 REAL_VALUE_TYPE r1
= TREE_REAL_CST (t1
);
1249 REAL_VALUE_TYPE r2
= TREE_REAL_CST (t2
);
1251 || r1
.decimal
!= r2
.decimal
1252 || r1
.sign
!= r2
.sign
1253 || r1
.signalling
!= r2
.signalling
1254 || r1
.canonical
!= r2
.canonical
1255 || r1
.uexp
!= r2
.uexp
)
1257 for (unsigned i
= 0; i
< SIGSZ
; ++i
)
1258 if (r1
.sig
[i
] != r2
.sig
[i
])
1262 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
1263 if (!fixed_compare (EQ_EXPR
,
1264 TREE_FIXED_CST_PTR (t1
), TREE_FIXED_CST_PTR (t2
)))
1268 /* We don't want to compare locations, so there is nothing do compare
1269 for TS_DECL_MINIMAL. */
1271 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1273 compare_values (DECL_MODE
);
1274 compare_values (DECL_NONLOCAL
);
1275 compare_values (DECL_VIRTUAL_P
);
1276 compare_values (DECL_IGNORED_P
);
1277 compare_values (DECL_ABSTRACT_P
);
1278 compare_values (DECL_ARTIFICIAL
);
1279 compare_values (DECL_USER_ALIGN
);
1280 compare_values (DECL_PRESERVE_P
);
1281 compare_values (DECL_EXTERNAL
);
1282 compare_values (DECL_GIMPLE_REG_P
);
1283 compare_values (DECL_ALIGN
);
1284 if (code
== LABEL_DECL
)
1286 compare_values (EH_LANDING_PAD_NR
);
1287 compare_values (LABEL_DECL_UID
);
1289 else if (code
== FIELD_DECL
)
1291 compare_values (DECL_PACKED
);
1292 compare_values (DECL_NONADDRESSABLE_P
);
1293 compare_values (DECL_OFFSET_ALIGN
);
1295 else if (code
== VAR_DECL
)
1297 compare_values (DECL_HAS_DEBUG_EXPR_P
);
1298 compare_values (DECL_NONLOCAL_FRAME
);
1300 if (code
== RESULT_DECL
1301 || code
== PARM_DECL
1302 || code
== VAR_DECL
)
1304 compare_values (DECL_BY_REFERENCE
);
1305 if (code
== VAR_DECL
1306 || code
== PARM_DECL
)
1307 compare_values (DECL_HAS_VALUE_EXPR_P
);
1311 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
1312 compare_values (DECL_REGISTER
);
1314 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1316 compare_values (DECL_COMMON
);
1317 compare_values (DECL_DLLIMPORT_P
);
1318 compare_values (DECL_WEAK
);
1319 compare_values (DECL_SEEN_IN_BIND_EXPR_P
);
1320 compare_values (DECL_COMDAT
);
1321 compare_values (DECL_VISIBILITY
);
1322 compare_values (DECL_VISIBILITY_SPECIFIED
);
1323 if (code
== VAR_DECL
)
1325 compare_values (DECL_HARD_REGISTER
);
1326 /* DECL_IN_TEXT_SECTION is set during final asm output only. */
1327 compare_values (DECL_IN_CONSTANT_POOL
);
1331 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1333 compare_values (DECL_BUILT_IN_CLASS
);
1334 compare_values (DECL_STATIC_CONSTRUCTOR
);
1335 compare_values (DECL_STATIC_DESTRUCTOR
);
1336 compare_values (DECL_UNINLINABLE
);
1337 compare_values (DECL_POSSIBLY_INLINED
);
1338 compare_values (DECL_IS_NOVOPS
);
1339 compare_values (DECL_IS_RETURNS_TWICE
);
1340 compare_values (DECL_IS_MALLOC
);
1341 compare_values (DECL_IS_OPERATOR_NEW
);
1342 compare_values (DECL_DECLARED_INLINE_P
);
1343 compare_values (DECL_STATIC_CHAIN
);
1344 compare_values (DECL_NO_INLINE_WARNING_P
);
1345 compare_values (DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT
);
1346 compare_values (DECL_NO_LIMIT_STACK
);
1347 compare_values (DECL_DISREGARD_INLINE_LIMITS
);
1348 compare_values (DECL_PURE_P
);
1349 compare_values (DECL_LOOPING_CONST_OR_PURE_P
);
1350 compare_values (DECL_FINAL_P
);
1351 compare_values (DECL_CXX_CONSTRUCTOR_P
);
1352 compare_values (DECL_CXX_DESTRUCTOR_P
);
1353 if (DECL_BUILT_IN_CLASS (t1
) != NOT_BUILT_IN
)
1354 compare_values (DECL_FUNCTION_CODE
);
1357 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
1359 compare_values (TYPE_MODE
);
1360 compare_values (TYPE_STRING_FLAG
);
1361 compare_values (TYPE_NO_FORCE_BLK
);
1362 compare_values (TYPE_NEEDS_CONSTRUCTING
);
1363 if (RECORD_OR_UNION_TYPE_P (t1
))
1365 compare_values (TYPE_TRANSPARENT_AGGR
);
1366 compare_values (TYPE_FINAL_P
);
1368 else if (code
== ARRAY_TYPE
)
1369 compare_values (TYPE_NONALIASED_COMPONENT
);
1370 compare_values (TYPE_PACKED
);
1371 compare_values (TYPE_RESTRICT
);
1372 compare_values (TYPE_USER_ALIGN
);
1373 compare_values (TYPE_READONLY
);
1374 compare_values (TYPE_PRECISION
);
1375 compare_values (TYPE_ALIGN
);
1376 compare_values (TYPE_ALIAS_SET
);
1379 /* We don't want to compare locations, so there is nothing do compare
1382 /* BLOCKs are function local and we don't merge anything there, so
1383 simply refuse to merge. */
1384 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
1387 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
1388 if (strcmp (TRANSLATION_UNIT_LANGUAGE (t1
),
1389 TRANSLATION_UNIT_LANGUAGE (t2
)) != 0)
1392 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
))
1393 if (!cl_target_option_eq (TREE_TARGET_OPTION (t1
), TREE_TARGET_OPTION (t2
)))
1396 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
1397 if (memcmp (TREE_OPTIMIZATION (t1
), TREE_OPTIMIZATION (t2
),
1398 sizeof (struct cl_optimization
)) != 0)
1401 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1402 if (vec_safe_length (BINFO_BASE_ACCESSES (t1
))
1403 != vec_safe_length (BINFO_BASE_ACCESSES (t2
)))
1406 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1407 compare_values (CONSTRUCTOR_NELTS
);
1409 if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
1410 if (IDENTIFIER_LENGTH (t1
) != IDENTIFIER_LENGTH (t2
)
1411 || memcmp (IDENTIFIER_POINTER (t1
), IDENTIFIER_POINTER (t2
),
1412 IDENTIFIER_LENGTH (t1
)) != 0)
1415 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
1416 if (TREE_STRING_LENGTH (t1
) != TREE_STRING_LENGTH (t2
)
1417 || memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
1418 TREE_STRING_LENGTH (t1
)) != 0)
1421 if (code
== OMP_CLAUSE
)
1423 compare_values (OMP_CLAUSE_CODE
);
1424 switch (OMP_CLAUSE_CODE (t1
))
1426 case OMP_CLAUSE_DEFAULT
:
1427 compare_values (OMP_CLAUSE_DEFAULT_KIND
);
1429 case OMP_CLAUSE_SCHEDULE
:
1430 compare_values (OMP_CLAUSE_SCHEDULE_KIND
);
1432 case OMP_CLAUSE_DEPEND
:
1433 compare_values (OMP_CLAUSE_DEPEND_KIND
);
1435 case OMP_CLAUSE_MAP
:
1436 compare_values (OMP_CLAUSE_MAP_KIND
);
1438 case OMP_CLAUSE_PROC_BIND
:
1439 compare_values (OMP_CLAUSE_PROC_BIND_KIND
);
1441 case OMP_CLAUSE_REDUCTION
:
1442 compare_values (OMP_CLAUSE_REDUCTION_CODE
);
1443 compare_values (OMP_CLAUSE_REDUCTION_GIMPLE_INIT
);
1444 compare_values (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE
);
1451 #undef compare_values
1454 /* Compare pointer fields. */
1456 /* Recurse. Search & Replaced from DFS_write_tree_body.
1457 Folding the early checks into the compare_tree_edges recursion
1458 macro makes debugging way quicker as you are able to break on
1459 compare_tree_sccs_1 and simply finish until a call returns false
1460 to spot the SCC members with the difference. */
1461 #define compare_tree_edges(E1, E2) \
1463 tree t1_ = (E1), t2_ = (E2); \
1466 || !TREE_VISITED (t2_) \
1467 || (!TREE_ASM_WRITTEN (t2_) \
1468 && !compare_tree_sccs_1 (t1_, t2_, map)))) \
1470 /* Only non-NULL trees outside of the SCC may compare equal. */ \
1471 gcc_checking_assert (t1_ != t2_ || (!t2_ || !TREE_VISITED (t2_))); \
1474 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
1476 if (code
!= IDENTIFIER_NODE
)
1477 compare_tree_edges (TREE_TYPE (t1
), TREE_TYPE (t2
));
1480 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
1483 /* Note that the number of elements for EXPR has already been emitted
1484 in EXPR's header (see streamer_write_tree_header). */
1485 for (i
= 0; i
< VECTOR_CST_NELTS (t1
); ++i
)
1486 compare_tree_edges (VECTOR_CST_ELT (t1
, i
), VECTOR_CST_ELT (t2
, i
));
1489 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
1491 compare_tree_edges (TREE_REALPART (t1
), TREE_REALPART (t2
));
1492 compare_tree_edges (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
1495 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
1497 compare_tree_edges (DECL_NAME (t1
), DECL_NAME (t2
));
1498 /* ??? Global decls from different TUs have non-matching
1499 TRANSLATION_UNIT_DECLs. Only consider a small set of
1500 decls equivalent, we should not end up merging others. */
1501 if ((code
== TYPE_DECL
1502 || code
== NAMESPACE_DECL
1503 || code
== IMPORTED_DECL
1504 || code
== CONST_DECL
1505 || (VAR_OR_FUNCTION_DECL_P (t1
)
1506 && (TREE_PUBLIC (t1
) || DECL_EXTERNAL (t1
))))
1507 && DECL_FILE_SCOPE_P (t1
) && DECL_FILE_SCOPE_P (t2
))
1510 compare_tree_edges (DECL_CONTEXT (t1
), DECL_CONTEXT (t2
));
1513 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1515 compare_tree_edges (DECL_SIZE (t1
), DECL_SIZE (t2
));
1516 compare_tree_edges (DECL_SIZE_UNIT (t1
), DECL_SIZE_UNIT (t2
));
1517 compare_tree_edges (DECL_ATTRIBUTES (t1
), DECL_ATTRIBUTES (t2
));
1518 if ((code
== VAR_DECL
1519 || code
== PARM_DECL
)
1520 && DECL_HAS_VALUE_EXPR_P (t1
))
1521 compare_tree_edges (DECL_VALUE_EXPR (t1
), DECL_VALUE_EXPR (t2
));
1522 if (code
== VAR_DECL
1523 && DECL_HAS_DEBUG_EXPR_P (t1
))
1524 compare_tree_edges (DECL_DEBUG_EXPR (t1
), DECL_DEBUG_EXPR (t2
));
1525 /* LTO specific edges. */
1526 if (code
!= FUNCTION_DECL
1527 && code
!= TRANSLATION_UNIT_DECL
)
1528 compare_tree_edges (DECL_INITIAL (t1
), DECL_INITIAL (t2
));
1531 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
1533 if (code
== FUNCTION_DECL
)
1536 for (a1
= DECL_ARGUMENTS (t1
), a2
= DECL_ARGUMENTS (t2
);
1538 a1
= TREE_CHAIN (a1
), a2
= TREE_CHAIN (a2
))
1539 compare_tree_edges (a1
, a2
);
1540 compare_tree_edges (DECL_RESULT (t1
), DECL_RESULT (t2
));
1542 else if (code
== TYPE_DECL
)
1543 compare_tree_edges (DECL_ORIGINAL_TYPE (t1
), DECL_ORIGINAL_TYPE (t2
));
1546 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1548 /* Make sure we don't inadvertently set the assembler name. */
1549 if (DECL_ASSEMBLER_NAME_SET_P (t1
))
1550 compare_tree_edges (DECL_ASSEMBLER_NAME (t1
),
1551 DECL_ASSEMBLER_NAME (t2
));
1554 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
1556 compare_tree_edges (DECL_FIELD_OFFSET (t1
), DECL_FIELD_OFFSET (t2
));
1557 compare_tree_edges (DECL_BIT_FIELD_TYPE (t1
), DECL_BIT_FIELD_TYPE (t2
));
1558 compare_tree_edges (DECL_BIT_FIELD_REPRESENTATIVE (t1
),
1559 DECL_BIT_FIELD_REPRESENTATIVE (t2
));
1560 compare_tree_edges (DECL_FIELD_BIT_OFFSET (t1
),
1561 DECL_FIELD_BIT_OFFSET (t2
));
1562 compare_tree_edges (DECL_FCONTEXT (t1
), DECL_FCONTEXT (t2
));
1565 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1567 compare_tree_edges (DECL_FUNCTION_PERSONALITY (t1
),
1568 DECL_FUNCTION_PERSONALITY (t2
));
1569 compare_tree_edges (DECL_VINDEX (t1
), DECL_VINDEX (t2
));
1570 compare_tree_edges (DECL_FUNCTION_SPECIFIC_TARGET (t1
),
1571 DECL_FUNCTION_SPECIFIC_TARGET (t2
));
1572 compare_tree_edges (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t1
),
1573 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t2
));
1576 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
1578 compare_tree_edges (TYPE_SIZE (t1
), TYPE_SIZE (t2
));
1579 compare_tree_edges (TYPE_SIZE_UNIT (t1
), TYPE_SIZE_UNIT (t2
));
1580 compare_tree_edges (TYPE_ATTRIBUTES (t1
), TYPE_ATTRIBUTES (t2
));
1581 compare_tree_edges (TYPE_NAME (t1
), TYPE_NAME (t2
));
1582 /* Do not compare TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
1583 reconstructed during fixup. */
1584 /* Do not compare TYPE_NEXT_VARIANT, we reconstruct the variant lists
1586 compare_tree_edges (TYPE_MAIN_VARIANT (t1
), TYPE_MAIN_VARIANT (t2
));
1587 /* ??? Global types from different TUs have non-matching
1588 TRANSLATION_UNIT_DECLs. Still merge them if they are otherwise
1590 if (TYPE_FILE_SCOPE_P (t1
) && TYPE_FILE_SCOPE_P (t2
))
1593 compare_tree_edges (TYPE_CONTEXT (t1
), TYPE_CONTEXT (t2
));
1594 /* TYPE_CANONICAL is re-computed during type merging, so do not
1596 compare_tree_edges (TYPE_STUB_DECL (t1
), TYPE_STUB_DECL (t2
));
1599 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
1601 if (code
== ENUMERAL_TYPE
)
1602 compare_tree_edges (TYPE_VALUES (t1
), TYPE_VALUES (t2
));
1603 else if (code
== ARRAY_TYPE
)
1604 compare_tree_edges (TYPE_DOMAIN (t1
), TYPE_DOMAIN (t2
));
1605 else if (RECORD_OR_UNION_TYPE_P (t1
))
1608 for (f1
= TYPE_FIELDS (t1
), f2
= TYPE_FIELDS (t2
);
1610 f1
= TREE_CHAIN (f1
), f2
= TREE_CHAIN (f2
))
1611 compare_tree_edges (f1
, f2
);
1612 compare_tree_edges (TYPE_BINFO (t1
), TYPE_BINFO (t2
));
1614 else if (code
== FUNCTION_TYPE
1615 || code
== METHOD_TYPE
)
1616 compare_tree_edges (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
));
1617 if (!POINTER_TYPE_P (t1
))
1618 compare_tree_edges (TYPE_MINVAL (t1
), TYPE_MINVAL (t2
));
1619 compare_tree_edges (TYPE_MAXVAL (t1
), TYPE_MAXVAL (t2
));
1622 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
1624 compare_tree_edges (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
));
1625 compare_tree_edges (TREE_VALUE (t1
), TREE_VALUE (t2
));
1626 compare_tree_edges (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
1629 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1630 for (int i
= 0; i
< TREE_VEC_LENGTH (t1
); i
++)
1631 compare_tree_edges (TREE_VEC_ELT (t1
, i
), TREE_VEC_ELT (t2
, i
));
1633 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
1635 for (int i
= 0; i
< TREE_OPERAND_LENGTH (t1
); i
++)
1636 compare_tree_edges (TREE_OPERAND (t1
, i
),
1637 TREE_OPERAND (t2
, i
));
1639 /* BLOCKs are function local and we don't merge anything there. */
1640 if (TREE_BLOCK (t1
) || TREE_BLOCK (t2
))
1644 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1648 /* Lengths have already been compared above. */
1649 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (t1
), i
, t
)
1650 compare_tree_edges (t
, BINFO_BASE_BINFO (t2
, i
));
1651 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (t1
), i
, t
)
1652 compare_tree_edges (t
, BINFO_BASE_ACCESS (t2
, i
));
1653 compare_tree_edges (BINFO_OFFSET (t1
), BINFO_OFFSET (t2
));
1654 compare_tree_edges (BINFO_VTABLE (t1
), BINFO_VTABLE (t2
));
1655 compare_tree_edges (BINFO_VPTR_FIELD (t1
), BINFO_VPTR_FIELD (t2
));
1656 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
1657 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
1660 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1664 /* Lengths have already been compared above. */
1665 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, index
, value
)
1667 compare_tree_edges (index
, CONSTRUCTOR_ELT (t2
, i
)->index
);
1668 compare_tree_edges (value
, CONSTRUCTOR_ELT (t2
, i
)->value
);
1672 if (code
== OMP_CLAUSE
)
1676 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (t1
)]; i
++)
1677 compare_tree_edges (OMP_CLAUSE_OPERAND (t1
, i
),
1678 OMP_CLAUSE_OPERAND (t2
, i
));
1679 compare_tree_edges (OMP_CLAUSE_CHAIN (t1
), OMP_CLAUSE_CHAIN (t2
));
1682 #undef compare_tree_edges
1687 /* Compare the tree scc SCC to the prevailing candidate PSCC, filling
1688 out MAP if they are equal. */
1691 compare_tree_sccs (tree_scc
*pscc
, tree_scc
*scc
,
1694 /* Assume SCC entry hashes are sorted after their cardinality. Which
1695 means we can simply take the first n-tuple of equal hashes
1696 (which is recorded as entry_len) and do n SCC entry candidate
1698 for (unsigned i
= 0; i
< pscc
->entry_len
; ++i
)
1701 num_scc_compare_collisions
++;
1702 if (compare_tree_sccs_1 (pscc
->entries
[0], scc
->entries
[i
], &mapp
))
1704 /* Equal - no need to reset TREE_VISITED or TREE_ASM_WRITTEN
1705 on the scc as all trees will be freed. */
1708 /* Reset TREE_ASM_WRITTEN on scc for the next compare or in case
1709 the SCC prevails. */
1710 for (unsigned j
= 0; j
< scc
->len
; ++j
)
1711 TREE_ASM_WRITTEN (scc
->entries
[j
]) = 0;
1717 /* QSort sort function to sort a map of two pointers after the 2nd
1721 cmp_tree (const void *p1_
, const void *p2_
)
1723 tree
*p1
= (tree
*)(const_cast<void *>(p1_
));
1724 tree
*p2
= (tree
*)(const_cast<void *>(p2_
));
1727 return ((uintptr_t)p1
[1] < (uintptr_t)p2
[1]) ? -1 : 1;
1730 /* Try to unify the SCC with nodes FROM to FROM + LEN in CACHE and
1731 hash value SCC_HASH with an already recorded SCC. Return true if
1732 that was successful, otherwise return false. */
1735 unify_scc (struct streamer_tree_cache_d
*cache
, unsigned from
,
1736 unsigned len
, unsigned scc_entry_len
, hashval_t scc_hash
)
1738 bool unified_p
= false;
1740 = (tree_scc
*) alloca (sizeof (tree_scc
) + (len
- 1) * sizeof (tree
));
1742 scc
->hash
= scc_hash
;
1744 scc
->entry_len
= scc_entry_len
;
1745 for (unsigned i
= 0; i
< len
; ++i
)
1747 tree t
= streamer_tree_cache_get_tree (cache
, from
+ i
);
1748 scc
->entries
[i
] = t
;
1749 /* Do not merge SCCs with local entities inside them. Also do
1750 not merge TRANSLATION_UNIT_DECLs. */
1751 if (TREE_CODE (t
) == TRANSLATION_UNIT_DECL
1752 || (VAR_OR_FUNCTION_DECL_P (t
)
1753 && !(TREE_PUBLIC (t
) || DECL_EXTERNAL (t
)))
1754 || TREE_CODE (t
) == LABEL_DECL
)
1756 /* Avoid doing any work for these cases and do not worry to
1757 record the SCCs for further merging. */
1762 /* Look for the list of candidate SCCs to compare against. */
1764 slot
= tree_scc_hash
->find_slot_with_hash (scc
, scc_hash
, INSERT
);
1767 /* Try unifying against each candidate. */
1770 /* Set TREE_VISITED on the scc so we can easily identify tree nodes
1771 outside of the scc when following tree edges. Make sure
1772 that TREE_ASM_WRITTEN is unset so we can use it as 2nd bit
1773 to track whether we visited the SCC member during the compare.
1774 We cannot use TREE_VISITED on the pscc members as the extended
1775 scc and pscc can overlap. */
1776 for (unsigned i
= 0; i
< scc
->len
; ++i
)
1778 TREE_VISITED (scc
->entries
[i
]) = 1;
1779 gcc_checking_assert (!TREE_ASM_WRITTEN (scc
->entries
[i
]));
1782 tree
*map
= XALLOCAVEC (tree
, 2 * len
);
1783 for (tree_scc
*pscc
= *slot
; pscc
; pscc
= pscc
->next
)
1785 if (!compare_tree_sccs (pscc
, scc
, map
))
1788 /* Found an equal SCC. */
1790 num_scc_compare_collisions
--;
1792 total_scc_size_merged
+= len
;
1794 #ifdef ENABLE_CHECKING
1795 for (unsigned i
= 0; i
< len
; ++i
)
1797 tree t
= map
[2*i
+1];
1798 enum tree_code code
= TREE_CODE (t
);
1799 /* IDENTIFIER_NODEs should be singletons and are merged by the
1800 streamer. The others should be singletons, too, and we
1801 should not merge them in any way. */
1802 gcc_assert (code
!= TRANSLATION_UNIT_DECL
1803 && code
!= IDENTIFIER_NODE
1804 && !streamer_handle_as_builtin_p (t
));
1808 /* Fixup the streamer cache with the prevailing nodes according
1809 to the tree node mapping computed by compare_tree_sccs. */
1811 streamer_tree_cache_replace_tree (cache
, pscc
->entries
[0], from
);
1814 tree
*map2
= XALLOCAVEC (tree
, 2 * len
);
1815 for (unsigned i
= 0; i
< len
; ++i
)
1817 map2
[i
*2] = (tree
)(uintptr_t)(from
+ i
);
1818 map2
[i
*2+1] = scc
->entries
[i
];
1820 qsort (map2
, len
, 2 * sizeof (tree
), cmp_tree
);
1821 qsort (map
, len
, 2 * sizeof (tree
), cmp_tree
);
1822 for (unsigned i
= 0; i
< len
; ++i
)
1823 streamer_tree_cache_replace_tree (cache
, map
[2*i
],
1824 (uintptr_t)map2
[2*i
]);
1827 /* Free the tree nodes from the read SCC. */
1828 for (unsigned i
= 0; i
< len
; ++i
)
1830 enum tree_code code
;
1831 if (TYPE_P (scc
->entries
[i
]))
1833 code
= TREE_CODE (scc
->entries
[i
]);
1834 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1835 vec_free (CONSTRUCTOR_ELTS (scc
->entries
[i
]));
1836 ggc_free (scc
->entries
[i
]);
1842 /* Reset TREE_VISITED if we didn't unify the SCC with another. */
1844 for (unsigned i
= 0; i
< scc
->len
; ++i
)
1845 TREE_VISITED (scc
->entries
[i
]) = 0;
1848 /* If we didn't unify it to any candidate duplicate the relevant
1849 pieces to permanent storage and link it into the chain. */
1853 = XOBNEWVAR (&tree_scc_hash_obstack
, tree_scc
, sizeof (tree_scc
));
1854 memcpy (pscc
, scc
, sizeof (tree_scc
));
1855 pscc
->next
= (*slot
);
1862 /* Read all the symbols from buffer DATA, using descriptors in DECL_DATA.
1863 RESOLUTIONS is the set of symbols picked by the linker (read from the
1864 resolution file when the linker plugin is being used). */
1867 lto_read_decls (struct lto_file_decl_data
*decl_data
, const void *data
,
1868 vec
<ld_plugin_symbol_resolution_t
> resolutions
)
1870 const struct lto_decl_header
*header
= (const struct lto_decl_header
*) data
;
1871 const int decl_offset
= sizeof (struct lto_decl_header
);
1872 const int main_offset
= decl_offset
+ header
->decl_state_size
;
1873 const int string_offset
= main_offset
+ header
->main_size
;
1874 struct data_in
*data_in
;
1876 const uint32_t *data_ptr
, *data_end
;
1877 uint32_t num_decl_states
;
1879 lto_input_block
ib_main ((const char *) data
+ main_offset
,
1882 data_in
= lto_data_in_create (decl_data
, (const char *) data
+ string_offset
,
1883 header
->string_size
, resolutions
);
1885 /* We do not uniquify the pre-loaded cache entries, those are middle-end
1886 internal types that should not be merged. */
1888 /* Read the global declarations and types. */
1889 while (ib_main
.p
< ib_main
.len
)
1892 unsigned from
= data_in
->reader_cache
->nodes
.length ();
1893 /* Read and uniquify SCCs as in the input stream. */
1894 enum LTO_tags tag
= streamer_read_record_start (&ib_main
);
1895 if (tag
== LTO_tree_scc
)
1898 unsigned scc_entry_len
;
1899 hashval_t scc_hash
= lto_input_scc (&ib_main
, data_in
, &len_
,
1901 unsigned len
= data_in
->reader_cache
->nodes
.length () - from
;
1902 gcc_assert (len
== len_
);
1904 total_scc_size
+= len
;
1907 /* We have the special case of size-1 SCCs that are pre-merged
1908 by means of identifier and string sharing for example.
1909 ??? Maybe we should avoid streaming those as SCCs. */
1910 tree first
= streamer_tree_cache_get_tree (data_in
->reader_cache
,
1913 && (TREE_CODE (first
) == IDENTIFIER_NODE
1914 || TREE_CODE (first
) == INTEGER_CST
1915 || TREE_CODE (first
) == TRANSLATION_UNIT_DECL
1916 || streamer_handle_as_builtin_p (first
)))
1919 /* Try to unify the SCC with already existing ones. */
1921 && unify_scc (data_in
->reader_cache
, from
,
1922 len
, scc_entry_len
, scc_hash
))
1925 bool seen_type
= false;
1926 for (unsigned i
= 0; i
< len
; ++i
)
1928 tree t
= streamer_tree_cache_get_tree (data_in
->reader_cache
,
1930 /* Reconstruct the type variant and pointer-to/reference-to
1935 num_prevailing_types
++;
1936 lto_fixup_prevailing_type (t
);
1938 /* Compute the canonical type of all types.
1939 ??? Should be able to assert that !TYPE_CANONICAL. */
1940 if (TYPE_P (t
) && !TYPE_CANONICAL (t
))
1942 gimple_register_canonical_type (t
);
1944 register_odr_type (t
);
1946 /* Link shared INTEGER_CSTs into TYPE_CACHED_VALUEs of its
1947 type which is also member of this SCC. */
1948 if (TREE_CODE (t
) == INTEGER_CST
1949 && !TREE_OVERFLOW (t
))
1950 cache_integer_cst (t
);
1951 /* Register TYPE_DECLs with the debuginfo machinery. */
1953 && TREE_CODE (t
) == TYPE_DECL
)
1954 debug_hooks
->type_decl (t
, !DECL_FILE_SCOPE_P (t
));
1957 /* Register variables and functions with the
1959 if (TREE_CODE (t
) == VAR_DECL
)
1960 lto_register_var_decl_in_symtab (data_in
, t
, from
+ i
);
1961 else if (TREE_CODE (t
) == FUNCTION_DECL
1962 && !DECL_BUILT_IN (t
))
1963 lto_register_function_decl_in_symtab (data_in
, t
, from
+ i
);
1964 /* Scan the tree for references to global functions or
1965 variables and record those for later fixup. */
1966 if (mentions_vars_p (t
))
1967 vec_safe_push (tree_with_vars
, t
);
1971 num_type_scc_trees
+= len
;
1975 /* Pickle stray references. */
1976 t
= lto_input_tree_1 (&ib_main
, data_in
, tag
, 0);
1977 gcc_assert (t
&& data_in
->reader_cache
->nodes
.length () == from
);
1981 /* Read in lto_in_decl_state objects. */
1982 data_ptr
= (const uint32_t *) ((const char*) data
+ decl_offset
);
1984 (const uint32_t *) ((const char*) data_ptr
+ header
->decl_state_size
);
1985 num_decl_states
= *data_ptr
++;
1987 gcc_assert (num_decl_states
> 0);
1988 decl_data
->global_decl_state
= lto_new_in_decl_state ();
1989 data_ptr
= lto_read_in_decl_state (data_in
, data_ptr
,
1990 decl_data
->global_decl_state
);
1992 /* Read in per-function decl states and enter them in hash table. */
1993 decl_data
->function_decl_states
=
1994 hash_table
<decl_state_hasher
>::create_ggc (37);
1996 for (i
= 1; i
< num_decl_states
; i
++)
1998 struct lto_in_decl_state
*state
= lto_new_in_decl_state ();
2000 data_ptr
= lto_read_in_decl_state (data_in
, data_ptr
, state
);
2001 lto_in_decl_state
**slot
2002 = decl_data
->function_decl_states
->find_slot (state
, INSERT
);
2003 gcc_assert (*slot
== NULL
);
2007 if (data_ptr
!= data_end
)
2008 internal_error ("bytecode stream: garbage at the end of symbols section");
2010 /* Set the current decl state to be the global state. */
2011 decl_data
->current_decl_state
= decl_data
->global_decl_state
;
2013 lto_data_in_delete (data_in
);
2016 /* Custom version of strtoll, which is not portable. */
2019 lto_parse_hex (const char *p
)
2023 for (; *p
!= '\0'; ++p
)
2028 if (c
>= '0' && c
<= '9')
2030 else if (c
>= 'a' && c
<= 'f')
2031 part
= c
- 'a' + 10;
2032 else if (c
>= 'A' && c
<= 'F')
2033 part
= c
- 'A' + 10;
2035 internal_error ("could not parse hex number");
2042 /* Read resolution for file named FILE_NAME. The resolution is read from
2046 lto_resolution_read (splay_tree file_ids
, FILE *resolution
, lto_file
*file
)
2048 /* We require that objects in the resolution file are in the same
2049 order as the lto1 command line. */
2050 unsigned int name_len
;
2052 unsigned int num_symbols
;
2054 struct lto_file_decl_data
*file_data
;
2055 splay_tree_node nd
= NULL
;
2060 name_len
= strlen (file
->filename
);
2061 obj_name
= XNEWVEC (char, name_len
+ 1);
2062 fscanf (resolution
, " "); /* Read white space. */
2064 fread (obj_name
, sizeof (char), name_len
, resolution
);
2065 obj_name
[name_len
] = '\0';
2066 if (filename_cmp (obj_name
, file
->filename
) != 0)
2067 internal_error ("unexpected file name %s in linker resolution file. "
2068 "Expected %s", obj_name
, file
->filename
);
2069 if (file
->offset
!= 0)
2074 t
= fscanf (resolution
, "@0x%16s", offset_p
);
2076 internal_error ("could not parse file offset");
2077 offset
= lto_parse_hex (offset_p
);
2078 if (offset
!= file
->offset
)
2079 internal_error ("unexpected offset");
2084 fscanf (resolution
, "%u", &num_symbols
);
2086 for (i
= 0; i
< num_symbols
; i
++)
2090 unsigned HOST_WIDE_INT id
;
2092 enum ld_plugin_symbol_resolution r
= (enum ld_plugin_symbol_resolution
) 0;
2094 unsigned int lto_resolution_str_len
=
2095 sizeof (lto_resolution_str
) / sizeof (char *);
2098 t
= fscanf (resolution
, "%u " HOST_WIDE_INT_PRINT_HEX_PURE
" %26s %*[^\n]\n",
2099 &index
, &id
, r_str
);
2101 internal_error ("invalid line in the resolution file");
2103 for (j
= 0; j
< lto_resolution_str_len
; j
++)
2105 if (strcmp (lto_resolution_str
[j
], r_str
) == 0)
2107 r
= (enum ld_plugin_symbol_resolution
) j
;
2111 if (j
== lto_resolution_str_len
)
2112 internal_error ("invalid resolution in the resolution file");
2114 if (!(nd
&& lto_splay_tree_id_equal_p (nd
->key
, id
)))
2116 nd
= lto_splay_tree_lookup (file_ids
, id
);
2118 internal_error ("resolution sub id %wx not in object file", id
);
2121 file_data
= (struct lto_file_decl_data
*)nd
->value
;
2122 /* The indexes are very sparse. To save memory save them in a compact
2123 format that is only unpacked later when the subfile is processed. */
2126 file_data
->respairs
.safe_push (rp
);
2127 if (file_data
->max_index
< index
)
2128 file_data
->max_index
= index
;
2132 /* List of file_decl_datas */
2133 struct file_data_list
2135 struct lto_file_decl_data
*first
, *last
;
2138 /* Is the name for a id'ed LTO section? */
2141 lto_section_with_id (const char *name
, unsigned HOST_WIDE_INT
*id
)
2145 if (strncmp (name
, section_name_prefix
, strlen (section_name_prefix
)))
2147 s
= strrchr (name
, '.');
2148 return s
&& sscanf (s
, "." HOST_WIDE_INT_PRINT_HEX_PURE
, id
) == 1;
2151 /* Create file_data of each sub file id */
2154 create_subid_section_table (struct lto_section_slot
*ls
, splay_tree file_ids
,
2155 struct file_data_list
*list
)
2157 struct lto_section_slot s_slot
, *new_slot
;
2158 unsigned HOST_WIDE_INT id
;
2162 struct lto_file_decl_data
*file_data
;
2164 if (!lto_section_with_id (ls
->name
, &id
))
2167 /* Find hash table of sub module id */
2168 nd
= lto_splay_tree_lookup (file_ids
, id
);
2171 file_data
= (struct lto_file_decl_data
*)nd
->value
;
2175 file_data
= ggc_alloc
<lto_file_decl_data
> ();
2176 memset(file_data
, 0, sizeof (struct lto_file_decl_data
));
2178 file_data
->section_hash_table
= lto_obj_create_section_hash_table ();;
2179 lto_splay_tree_insert (file_ids
, id
, file_data
);
2181 /* Maintain list in linker order */
2183 list
->first
= file_data
;
2185 list
->last
->next
= file_data
;
2186 list
->last
= file_data
;
2189 /* Copy section into sub module hash table */
2190 new_name
= XDUPVEC (char, ls
->name
, strlen (ls
->name
) + 1);
2191 s_slot
.name
= new_name
;
2192 hash_slot
= htab_find_slot (file_data
->section_hash_table
, &s_slot
, INSERT
);
2193 gcc_assert (*hash_slot
== NULL
);
2195 new_slot
= XDUP (struct lto_section_slot
, ls
);
2196 new_slot
->name
= new_name
;
2197 *hash_slot
= new_slot
;
2201 /* Read declarations and other initializations for a FILE_DATA. */
2204 lto_file_finalize (struct lto_file_decl_data
*file_data
, lto_file
*file
)
2208 vec
<ld_plugin_symbol_resolution_t
>
2209 resolutions
= vNULL
;
2213 /* Create vector for fast access of resolution. We do this lazily
2215 resolutions
.safe_grow_cleared (file_data
->max_index
+ 1);
2216 for (i
= 0; file_data
->respairs
.iterate (i
, &rp
); i
++)
2217 resolutions
[rp
->index
] = rp
->res
;
2218 file_data
->respairs
.release ();
2220 file_data
->renaming_hash_table
= lto_create_renaming_table ();
2221 file_data
->file_name
= file
->filename
;
2222 data
= lto_get_section_data (file_data
, LTO_section_decls
, NULL
, &len
);
2225 internal_error ("cannot read LTO decls from %s", file_data
->file_name
);
2228 /* Frees resolutions */
2229 lto_read_decls (file_data
, data
, resolutions
);
2230 lto_free_section_data (file_data
, LTO_section_decls
, NULL
, data
, len
);
2233 /* Finalize FILE_DATA in FILE and increase COUNT. */
2236 lto_create_files_from_ids (lto_file
*file
, struct lto_file_decl_data
*file_data
,
2239 lto_file_finalize (file_data
, file
);
2240 if (symtab
->dump_file
)
2241 fprintf (symtab
->dump_file
,
2242 "Creating file %s with sub id " HOST_WIDE_INT_PRINT_HEX
"\n",
2243 file_data
->file_name
, file_data
->id
);
2248 /* Generate a TREE representation for all types and external decls
2251 Read all of the globals out of the file. Then read the cgraph
2252 and process the .o index into the cgraph nodes so that it can open
2253 the .o file to load the functions and ipa information. */
2255 static struct lto_file_decl_data
*
2256 lto_file_read (lto_file
*file
, FILE *resolution_file
, int *count
)
2258 struct lto_file_decl_data
*file_data
= NULL
;
2259 splay_tree file_ids
;
2260 htab_t section_hash_table
;
2261 struct lto_section_slot
*section
;
2262 struct file_data_list file_list
;
2263 struct lto_section_list section_list
;
2265 memset (§ion_list
, 0, sizeof (struct lto_section_list
));
2266 section_hash_table
= lto_obj_build_section_table (file
, §ion_list
);
2268 /* Find all sub modules in the object and put their sections into new hash
2269 tables in a splay tree. */
2270 file_ids
= lto_splay_tree_new ();
2271 memset (&file_list
, 0, sizeof (struct file_data_list
));
2272 for (section
= section_list
.first
; section
!= NULL
; section
= section
->next
)
2273 create_subid_section_table (section
, file_ids
, &file_list
);
2275 /* Add resolutions to file ids */
2276 lto_resolution_read (file_ids
, resolution_file
, file
);
2278 /* Finalize each lto file for each submodule in the merged object */
2279 for (file_data
= file_list
.first
; file_data
!= NULL
; file_data
= file_data
->next
)
2280 lto_create_files_from_ids (file
, file_data
, count
);
2282 splay_tree_delete (file_ids
);
2283 htab_delete (section_hash_table
);
2285 return file_list
.first
;
2288 #if HAVE_MMAP_FILE && HAVE_SYSCONF && defined _SC_PAGE_SIZE
2289 #define LTO_MMAP_IO 1
2293 /* Page size of machine is used for mmap and munmap calls. */
2294 static size_t page_mask
;
2297 /* Get the section data of length LEN from FILENAME starting at
2298 OFFSET. The data segment must be freed by the caller when the
2299 caller is finished. Returns NULL if all was not well. */
2302 lto_read_section_data (struct lto_file_decl_data
*file_data
,
2303 intptr_t offset
, size_t len
)
2307 static char *fd_name
;
2309 intptr_t computed_len
;
2310 intptr_t computed_offset
;
2314 /* Keep a single-entry file-descriptor cache. The last file we
2315 touched will get closed at exit.
2316 ??? Eventually we want to add a more sophisticated larger cache
2317 or rather fix function body streaming to not stream them in
2318 practically random order. */
2320 && filename_cmp (fd_name
, file_data
->file_name
) != 0)
2328 fd
= open (file_data
->file_name
, O_RDONLY
|O_BINARY
);
2331 fatal_error ("Cannot open %s", file_data
->file_name
);
2334 fd_name
= xstrdup (file_data
->file_name
);
2340 size_t page_size
= sysconf (_SC_PAGE_SIZE
);
2341 page_mask
= ~(page_size
- 1);
2344 computed_offset
= offset
& page_mask
;
2345 diff
= offset
- computed_offset
;
2346 computed_len
= len
+ diff
;
2348 result
= (char *) mmap (NULL
, computed_len
, PROT_READ
, MAP_PRIVATE
,
2349 fd
, computed_offset
);
2350 if (result
== MAP_FAILED
)
2352 fatal_error ("Cannot map %s", file_data
->file_name
);
2356 return result
+ diff
;
2358 result
= (char *) xmalloc (len
);
2359 if (lseek (fd
, offset
, SEEK_SET
) != offset
2360 || read (fd
, result
, len
) != (ssize_t
) len
)
2363 fatal_error ("Cannot read %s", file_data
->file_name
);
2367 /* Native windows doesn't supports delayed unlink on opened file. So
2368 we close file here again. This produces higher I/O load, but at least
2369 it prevents to have dangling file handles preventing unlink. */
2380 /* Get the section data from FILE_DATA of SECTION_TYPE with NAME.
2381 NAME will be NULL unless the section type is for a function
2385 get_section_data (struct lto_file_decl_data
*file_data
,
2386 enum lto_section_type section_type
,
2390 htab_t section_hash_table
= file_data
->section_hash_table
;
2391 struct lto_section_slot
*f_slot
;
2392 struct lto_section_slot s_slot
;
2393 const char *section_name
= lto_get_section_name (section_type
, name
, file_data
);
2397 s_slot
.name
= section_name
;
2398 f_slot
= (struct lto_section_slot
*) htab_find (section_hash_table
, &s_slot
);
2401 data
= lto_read_section_data (file_data
, f_slot
->start
, f_slot
->len
);
2405 free (CONST_CAST (char *, section_name
));
2410 /* Free the section data from FILE_DATA of SECTION_TYPE with NAME that
2411 starts at OFFSET and has LEN bytes. */
2414 free_section_data (struct lto_file_decl_data
*file_data ATTRIBUTE_UNUSED
,
2415 enum lto_section_type section_type ATTRIBUTE_UNUSED
,
2416 const char *name ATTRIBUTE_UNUSED
,
2417 const char *offset
, size_t len ATTRIBUTE_UNUSED
)
2420 intptr_t computed_len
;
2421 intptr_t computed_offset
;
2426 computed_offset
= ((intptr_t) offset
) & page_mask
;
2427 diff
= (intptr_t) offset
- computed_offset
;
2428 computed_len
= len
+ diff
;
2430 munmap ((caddr_t
) computed_offset
, computed_len
);
2432 free (CONST_CAST(char *, offset
));
2436 static lto_file
*current_lto_file
;
2438 /* Helper for qsort; compare partitions and return one with smaller size.
2439 We sort from greatest to smallest so parallel build doesn't stale on the
2440 longest compilation being executed too late. */
2443 cmp_partitions_size (const void *a
, const void *b
)
2445 const struct ltrans_partition_def
*pa
2446 = *(struct ltrans_partition_def
*const *)a
;
2447 const struct ltrans_partition_def
*pb
2448 = *(struct ltrans_partition_def
*const *)b
;
2449 return pb
->insns
- pa
->insns
;
2452 /* Helper for qsort; compare partitions and return one with smaller order. */
2455 cmp_partitions_order (const void *a
, const void *b
)
2457 const struct ltrans_partition_def
*pa
2458 = *(struct ltrans_partition_def
*const *)a
;
2459 const struct ltrans_partition_def
*pb
2460 = *(struct ltrans_partition_def
*const *)b
;
2461 int ordera
= -1, orderb
= -1;
2463 if (lto_symtab_encoder_size (pa
->encoder
))
2464 ordera
= lto_symtab_encoder_deref (pa
->encoder
, 0)->order
;
2465 if (lto_symtab_encoder_size (pb
->encoder
))
2466 orderb
= lto_symtab_encoder_deref (pb
->encoder
, 0)->order
;
2467 return orderb
- ordera
;
2470 /* Actually stream out ENCODER into TEMP_FILENAME. */
2473 do_stream_out (char *temp_filename
, lto_symtab_encoder_t encoder
)
2475 lto_file
*file
= lto_obj_file_open (temp_filename
, true);
2477 fatal_error ("lto_obj_file_open() failed");
2478 lto_set_current_out_file (file
);
2480 ipa_write_optimization_summaries (encoder
);
2482 lto_set_current_out_file (NULL
);
2483 lto_obj_file_close (file
);
2487 /* Wait for forked process and signal errors. */
2488 #ifdef HAVE_WORKING_FORK
2496 #define WCONTINUED 0
2498 int w
= waitpid (0, &status
, WUNTRACED
| WCONTINUED
);
2500 fatal_error ("waitpid failed");
2502 if (WIFEXITED (status
) && WEXITSTATUS (status
))
2503 fatal_error ("streaming subprocess failed");
2504 else if (WIFSIGNALED (status
))
2505 fatal_error ("streaming subprocess was killed by signal");
2507 while (!WIFEXITED (status
) && !WIFSIGNALED (status
));
2511 /* Stream out ENCODER into TEMP_FILENAME
2512 Fork if that seems to help. */
2515 stream_out (char *temp_filename
, lto_symtab_encoder_t encoder
,
2516 bool ARG_UNUSED (last
))
2518 #ifdef HAVE_WORKING_FORK
2521 if (lto_parallelism
<= 1)
2523 do_stream_out (temp_filename
, encoder
);
2527 /* Do not run more than LTO_PARALLELISM streamings
2528 FIXME: we ignore limits on jobserver. */
2529 if (lto_parallelism
> 0 && nruns
>= lto_parallelism
)
2534 /* If this is not the last parallel partition, execute new
2535 streaming process. */
2538 pid_t cpid
= fork ();
2542 setproctitle ("lto1-wpa-streaming");
2543 do_stream_out (temp_filename
, encoder
);
2546 /* Fork failed; lets do the job ourseleves. */
2547 else if (cpid
== -1)
2548 do_stream_out (temp_filename
, encoder
);
2552 /* Last partition; stream it and wait for all children to die. */
2556 do_stream_out (temp_filename
, encoder
);
2557 for (i
= 0; i
< nruns
; i
++)
2560 asm_nodes_output
= true;
2562 do_stream_out (temp_filename
, encoder
);
2566 /* Write all output files in WPA mode and the file with the list of
2570 lto_wpa_write_files (void)
2573 ltrans_partition part
;
2574 FILE *ltrans_output_list_stream
;
2575 char *temp_filename
;
2576 vec
<char *>temp_filenames
= vNULL
;
2579 /* Open the LTRANS output list. */
2580 if (!ltrans_output_list
)
2581 fatal_error ("no LTRANS output list filename provided");
2583 timevar_push (TV_WHOPR_WPA
);
2585 FOR_EACH_VEC_ELT (ltrans_partitions
, i
, part
)
2586 lto_stats
.num_output_symtab_nodes
+= lto_symtab_encoder_size (part
->encoder
);
2588 timevar_pop (TV_WHOPR_WPA
);
2590 timevar_push (TV_WHOPR_WPA_IO
);
2592 /* Generate a prefix for the LTRANS unit files. */
2593 blen
= strlen (ltrans_output_list
);
2594 temp_filename
= (char *) xmalloc (blen
+ sizeof ("2147483648.o"));
2595 strcpy (temp_filename
, ltrans_output_list
);
2596 if (blen
> sizeof (".out")
2597 && strcmp (temp_filename
+ blen
- sizeof (".out") + 1,
2599 temp_filename
[blen
- sizeof (".out") + 1] = '\0';
2600 blen
= strlen (temp_filename
);
2602 n_sets
= ltrans_partitions
.length ();
2604 /* Sort partitions by size so small ones are compiled last.
2605 FIXME: Even when not reordering we may want to output one list for parallel make
2606 and other for final link command. */
2608 if (!flag_profile_reorder_functions
|| !flag_profile_use
)
2609 ltrans_partitions
.qsort (flag_toplevel_reorder
2610 ? cmp_partitions_size
2611 : cmp_partitions_order
);
2613 for (i
= 0; i
< n_sets
; i
++)
2615 ltrans_partition part
= ltrans_partitions
[i
];
2617 /* Write all the nodes in SET. */
2618 sprintf (temp_filename
+ blen
, "%u.o", i
);
2621 fprintf (stderr
, " %s (%s %i insns)", temp_filename
, part
->name
, part
->insns
);
2622 if (symtab
->dump_file
)
2624 lto_symtab_encoder_iterator lsei
;
2626 fprintf (symtab
->dump_file
, "Writing partition %s to file %s, %i insns\n",
2627 part
->name
, temp_filename
, part
->insns
);
2628 fprintf (symtab
->dump_file
, " Symbols in partition: ");
2629 for (lsei
= lsei_start_in_partition (part
->encoder
); !lsei_end_p (lsei
);
2630 lsei_next_in_partition (&lsei
))
2632 symtab_node
*node
= lsei_node (lsei
);
2633 fprintf (symtab
->dump_file
, "%s ", node
->asm_name ());
2635 fprintf (symtab
->dump_file
, "\n Symbols in boundary: ");
2636 for (lsei
= lsei_start (part
->encoder
); !lsei_end_p (lsei
);
2639 symtab_node
*node
= lsei_node (lsei
);
2640 if (!lto_symtab_encoder_in_partition_p (part
->encoder
, node
))
2642 fprintf (symtab
->dump_file
, "%s ", node
->asm_name ());
2643 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
);
2645 && lto_symtab_encoder_encode_body_p (part
->encoder
, cnode
))
2646 fprintf (symtab
->dump_file
, "(body included)");
2649 varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
);
2651 && lto_symtab_encoder_encode_initializer_p (part
->encoder
, vnode
))
2652 fprintf (symtab
->dump_file
, "(initializer included)");
2656 fprintf (symtab
->dump_file
, "\n");
2658 gcc_checking_assert (lto_symtab_encoder_size (part
->encoder
) || !i
);
2660 stream_out (temp_filename
, part
->encoder
, i
== n_sets
- 1);
2662 part
->encoder
= NULL
;
2664 temp_filenames
.safe_push (xstrdup (temp_filename
));
2666 ltrans_output_list_stream
= fopen (ltrans_output_list
, "w");
2667 if (ltrans_output_list_stream
== NULL
)
2668 fatal_error ("opening LTRANS output list %s: %m", ltrans_output_list
);
2669 for (i
= 0; i
< n_sets
; i
++)
2671 unsigned int len
= strlen (temp_filenames
[i
]);
2672 if (fwrite (temp_filenames
[i
], 1, len
, ltrans_output_list_stream
) < len
2673 || fwrite ("\n", 1, 1, ltrans_output_list_stream
) < 1)
2674 fatal_error ("writing to LTRANS output list %s: %m",
2675 ltrans_output_list
);
2676 free (temp_filenames
[i
]);
2678 temp_filenames
.release();
2680 lto_stats
.num_output_files
+= n_sets
;
2682 /* Close the LTRANS output list. */
2683 if (fclose (ltrans_output_list_stream
))
2684 fatal_error ("closing LTRANS output list %s: %m", ltrans_output_list
);
2686 free_ltrans_partitions();
2687 free (temp_filename
);
2689 timevar_pop (TV_WHOPR_WPA_IO
);
2693 /* If TT is a variable or function decl replace it with its
2694 prevailing variant. */
2695 #define LTO_SET_PREVAIL(tt) \
2697 if ((tt) && VAR_OR_FUNCTION_DECL_P (tt) \
2698 && (TREE_PUBLIC (tt) || DECL_EXTERNAL (tt))) \
2700 tt = lto_symtab_prevailing_decl (tt); \
2705 /* Ensure that TT isn't a replacable var of function decl. */
2706 #define LTO_NO_PREVAIL(tt) \
2707 gcc_assert (!(tt) || !VAR_OR_FUNCTION_DECL_P (tt))
2709 /* Given a tree T replace all fields referring to variables or functions
2710 with their prevailing variant. */
2712 lto_fixup_prevailing_decls (tree t
)
2714 enum tree_code code
= TREE_CODE (t
);
2717 gcc_checking_assert (code
!= TREE_BINFO
);
2718 LTO_NO_PREVAIL (TREE_TYPE (t
));
2719 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
2720 LTO_NO_PREVAIL (TREE_CHAIN (t
));
2723 LTO_NO_PREVAIL (DECL_NAME (t
));
2724 LTO_SET_PREVAIL (DECL_CONTEXT (t
));
2725 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
2727 LTO_SET_PREVAIL (DECL_SIZE (t
));
2728 LTO_SET_PREVAIL (DECL_SIZE_UNIT (t
));
2729 LTO_SET_PREVAIL (DECL_INITIAL (t
));
2730 LTO_NO_PREVAIL (DECL_ATTRIBUTES (t
));
2731 LTO_SET_PREVAIL (DECL_ABSTRACT_ORIGIN (t
));
2733 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
2735 LTO_NO_PREVAIL (t
->decl_with_vis
.assembler_name
);
2737 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
2739 LTO_NO_PREVAIL (DECL_RESULT_FLD (t
));
2741 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
2743 LTO_NO_PREVAIL (DECL_ARGUMENTS (t
));
2744 LTO_SET_PREVAIL (DECL_FUNCTION_PERSONALITY (t
));
2745 LTO_NO_PREVAIL (DECL_VINDEX (t
));
2747 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
2749 LTO_SET_PREVAIL (DECL_FIELD_OFFSET (t
));
2750 LTO_NO_PREVAIL (DECL_BIT_FIELD_TYPE (t
));
2751 LTO_NO_PREVAIL (DECL_QUALIFIER (t
));
2752 LTO_NO_PREVAIL (DECL_FIELD_BIT_OFFSET (t
));
2753 LTO_NO_PREVAIL (DECL_FCONTEXT (t
));
2756 else if (TYPE_P (t
))
2758 LTO_NO_PREVAIL (TYPE_CACHED_VALUES (t
));
2759 LTO_SET_PREVAIL (TYPE_SIZE (t
));
2760 LTO_SET_PREVAIL (TYPE_SIZE_UNIT (t
));
2761 LTO_NO_PREVAIL (TYPE_ATTRIBUTES (t
));
2762 LTO_NO_PREVAIL (TYPE_NAME (t
));
2764 LTO_SET_PREVAIL (TYPE_MINVAL (t
));
2765 LTO_SET_PREVAIL (TYPE_MAXVAL (t
));
2766 LTO_NO_PREVAIL (t
->type_non_common
.binfo
);
2768 LTO_SET_PREVAIL (TYPE_CONTEXT (t
));
2770 LTO_NO_PREVAIL (TYPE_CANONICAL (t
));
2771 LTO_NO_PREVAIL (TYPE_MAIN_VARIANT (t
));
2772 LTO_NO_PREVAIL (TYPE_NEXT_VARIANT (t
));
2774 else if (EXPR_P (t
))
2777 for (i
= TREE_OPERAND_LENGTH (t
) - 1; i
>= 0; --i
)
2778 LTO_SET_PREVAIL (TREE_OPERAND (t
, i
));
2780 else if (TREE_CODE (t
) == CONSTRUCTOR
)
2784 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), i
, val
)
2785 LTO_SET_PREVAIL (val
);
2792 LTO_SET_PREVAIL (TREE_VALUE (t
));
2793 LTO_SET_PREVAIL (TREE_PURPOSE (t
));
2794 LTO_NO_PREVAIL (TREE_PURPOSE (t
));
2800 /* If we fixed nothing, then we missed something seen by
2802 gcc_checking_assert (fixed
);
2804 #undef LTO_SET_PREVAIL
2805 #undef LTO_NO_PREVAIL
2807 /* Helper function of lto_fixup_decls. Walks the var and fn streams in STATE,
2808 replaces var and function decls with the corresponding prevailing def. */
2811 lto_fixup_state (struct lto_in_decl_state
*state
)
2815 /* Although we only want to replace FUNCTION_DECLs and VAR_DECLs,
2816 we still need to walk from all DECLs to find the reachable
2817 FUNCTION_DECLs and VAR_DECLs. */
2818 for (si
= 0; si
< LTO_N_DECL_STREAMS
; si
++)
2820 vec
<tree
, va_gc
> *trees
= state
->streams
[si
];
2821 for (i
= 0; i
< vec_safe_length (trees
); i
++)
2823 tree t
= (*trees
)[i
];
2824 if (VAR_OR_FUNCTION_DECL_P (t
)
2825 && (TREE_PUBLIC (t
) || DECL_EXTERNAL (t
)))
2826 (*trees
)[i
] = lto_symtab_prevailing_decl (t
);
2831 /* Fix the decls from all FILES. Replaces each decl with the corresponding
2835 lto_fixup_decls (struct lto_file_decl_data
**files
)
2841 FOR_EACH_VEC_ELT ((*tree_with_vars
), i
, t
)
2842 lto_fixup_prevailing_decls (t
);
2844 for (i
= 0; files
[i
]; i
++)
2846 struct lto_file_decl_data
*file
= files
[i
];
2847 struct lto_in_decl_state
*state
= file
->global_decl_state
;
2848 lto_fixup_state (state
);
2850 hash_table
<decl_state_hasher
>::iterator iter
;
2851 lto_in_decl_state
*elt
;
2852 FOR_EACH_HASH_TABLE_ELEMENT (*file
->function_decl_states
, elt
,
2853 lto_in_decl_state
*, iter
)
2854 lto_fixup_state (elt
);
2858 static GTY((length ("lto_stats.num_input_files + 1"))) struct lto_file_decl_data
**all_file_decl_data
;
2860 /* Turn file datas for sub files into a single array, so that they look
2861 like separate files for further passes. */
2864 lto_flatten_files (struct lto_file_decl_data
**orig
, int count
, int last_file_ix
)
2866 struct lto_file_decl_data
*n
, *next
;
2869 lto_stats
.num_input_files
= count
;
2871 = ggc_cleared_vec_alloc
<lto_file_decl_data_ptr
> (count
+ 1);
2872 /* Set the hooks so that all of the ipa passes can read in their data. */
2873 lto_set_in_hooks (all_file_decl_data
, get_section_data
, free_section_data
);
2874 for (i
= 0, k
= 0; i
< last_file_ix
; i
++)
2876 for (n
= orig
[i
]; n
!= NULL
; n
= next
)
2878 all_file_decl_data
[k
++] = n
;
2883 all_file_decl_data
[k
] = NULL
;
2884 gcc_assert (k
== count
);
2887 /* Input file data before flattening (i.e. splitting them to subfiles to support
2888 incremental linking. */
2889 static int real_file_count
;
2890 static GTY((length ("real_file_count + 1"))) struct lto_file_decl_data
**real_file_decl_data
;
2892 static void print_lto_report_1 (void);
2894 /* Read all the symbols from the input files FNAMES. NFILES is the
2895 number of files requested in the command line. Instantiate a
2896 global call graph by aggregating all the sub-graphs found in each
2900 read_cgraph_and_symbols (unsigned nfiles
, const char **fnames
)
2902 unsigned int i
, last_file_ix
;
2905 struct lto_file_decl_data
**decl_data
;
2908 symtab
->initialize ();
2910 timevar_push (TV_IPA_LTO_DECL_IN
);
2912 #ifdef ACCEL_COMPILER
2913 section_name_prefix
= OFFLOAD_SECTION_NAME_PREFIX
;
2914 lto_stream_offload_p
= true;
2918 = decl_data
= ggc_cleared_vec_alloc
<lto_file_decl_data_ptr
> (nfiles
+ 1);
2919 real_file_count
= nfiles
;
2921 /* Read the resolution file. */
2923 if (resolution_file_name
)
2926 unsigned num_objects
;
2928 resolution
= fopen (resolution_file_name
, "r");
2929 if (resolution
== NULL
)
2930 fatal_error ("could not open symbol resolution file: %m");
2932 t
= fscanf (resolution
, "%u", &num_objects
);
2933 gcc_assert (t
== 1);
2935 /* True, since the plugin splits the archives. */
2936 gcc_assert (num_objects
== nfiles
);
2938 symtab
->state
= LTO_STREAMING
;
2940 canonical_type_hash_cache
= new hash_map
<const_tree
, hashval_t
> (251);
2941 gimple_canonical_types
= htab_create (16381, gimple_canonical_type_hash
,
2942 gimple_canonical_type_eq
, NULL
);
2943 gcc_obstack_init (&tree_scc_hash_obstack
);
2944 tree_scc_hash
= new hash_table
<tree_scc_hasher
> (4096);
2946 /* Register the common node types with the canonical type machinery so
2947 we properly share alias-sets across languages and TUs. Do not
2948 expose the common nodes as type merge target - those that should be
2949 are already exposed so by pre-loading the LTO streamer caches.
2950 Do two passes - first clear TYPE_CANONICAL and then re-compute it. */
2951 for (i
= 0; i
< itk_none
; ++i
)
2952 lto_register_canonical_types (integer_types
[i
], true);
2953 for (i
= 0; i
< stk_type_kind_last
; ++i
)
2954 lto_register_canonical_types (sizetype_tab
[i
], true);
2955 for (i
= 0; i
< TI_MAX
; ++i
)
2956 lto_register_canonical_types (global_trees
[i
], true);
2957 for (i
= 0; i
< itk_none
; ++i
)
2958 lto_register_canonical_types (integer_types
[i
], false);
2959 for (i
= 0; i
< stk_type_kind_last
; ++i
)
2960 lto_register_canonical_types (sizetype_tab
[i
], false);
2961 for (i
= 0; i
< TI_MAX
; ++i
)
2962 lto_register_canonical_types (global_trees
[i
], false);
2965 fprintf (stderr
, "Reading object files:");
2967 /* Read all of the object files specified on the command line. */
2968 for (i
= 0, last_file_ix
= 0; i
< nfiles
; ++i
)
2970 struct lto_file_decl_data
*file_data
= NULL
;
2973 fprintf (stderr
, " %s", fnames
[i
]);
2977 current_lto_file
= lto_obj_file_open (fnames
[i
], false);
2978 if (!current_lto_file
)
2981 file_data
= lto_file_read (current_lto_file
, resolution
, &count
);
2984 lto_obj_file_close (current_lto_file
);
2985 free (current_lto_file
);
2986 current_lto_file
= NULL
;
2990 decl_data
[last_file_ix
++] = file_data
;
2992 lto_obj_file_close (current_lto_file
);
2993 free (current_lto_file
);
2994 current_lto_file
= NULL
;
2997 lto_flatten_files (decl_data
, count
, last_file_ix
);
2998 lto_stats
.num_input_files
= count
;
2999 ggc_free(decl_data
);
3000 real_file_decl_data
= NULL
;
3002 if (resolution_file_name
)
3003 fclose (resolution
);
3005 /* Show the LTO report before launching LTRANS. */
3006 if (flag_lto_report
|| (flag_wpa
&& flag_lto_report_wpa
))
3007 print_lto_report_1 ();
3009 /* Free gimple type merging datastructures. */
3010 delete tree_scc_hash
;
3011 tree_scc_hash
= NULL
;
3012 obstack_free (&tree_scc_hash_obstack
, NULL
);
3013 htab_delete (gimple_canonical_types
);
3014 gimple_canonical_types
= NULL
;
3015 delete canonical_type_hash_cache
;
3016 canonical_type_hash_cache
= NULL
;
3018 /* At this stage we know that majority of GGC memory is reachable.
3019 Growing the limits prevents unnecesary invocation of GGC. */
3023 /* Set the hooks so that all of the ipa passes can read in their data. */
3024 lto_set_in_hooks (all_file_decl_data
, get_section_data
, free_section_data
);
3026 timevar_pop (TV_IPA_LTO_DECL_IN
);
3029 fprintf (stderr
, "\nReading the callgraph\n");
3031 timevar_push (TV_IPA_LTO_CGRAPH_IO
);
3032 /* Read the symtab. */
3035 input_offload_tables ();
3037 /* Store resolutions into the symbol table. */
3039 ld_plugin_symbol_resolution_t
*res
;
3040 FOR_EACH_SYMBOL (snode
)
3041 if (snode
->real_symbol_p ()
3042 && snode
->lto_file_data
3043 && snode
->lto_file_data
->resolution_map
3044 && (res
= snode
->lto_file_data
->resolution_map
->get (snode
->decl
)))
3045 snode
->resolution
= *res
;
3046 for (i
= 0; all_file_decl_data
[i
]; i
++)
3047 if (all_file_decl_data
[i
]->resolution_map
)
3049 delete all_file_decl_data
[i
]->resolution_map
;
3050 all_file_decl_data
[i
]->resolution_map
= NULL
;
3053 timevar_pop (TV_IPA_LTO_CGRAPH_IO
);
3056 fprintf (stderr
, "Merging declarations\n");
3058 timevar_push (TV_IPA_LTO_DECL_MERGE
);
3059 /* Merge global decls. In ltrans mode we read merged cgraph, we do not
3060 need to care about resolving symbols again, we only need to replace
3061 duplicated declarations read from the callgraph and from function
3065 lto_symtab_merge_decls ();
3067 /* If there were errors during symbol merging bail out, we have no
3068 good way to recover here. */
3070 fatal_error ("errors during merging of translation units");
3072 /* Fixup all decls. */
3073 lto_fixup_decls (all_file_decl_data
);
3076 ggc_free (tree_with_vars
);
3077 tree_with_vars
= NULL
;
3080 timevar_pop (TV_IPA_LTO_DECL_MERGE
);
3081 /* Each pass will set the appropriate timer. */
3084 fprintf (stderr
, "Reading summaries\n");
3086 /* Read the IPA summary data. */
3088 ipa_read_optimization_summaries ();
3090 ipa_read_summaries ();
3092 for (i
= 0; all_file_decl_data
[i
]; i
++)
3094 gcc_assert (all_file_decl_data
[i
]->symtab_node_encoder
);
3095 lto_symtab_encoder_delete (all_file_decl_data
[i
]->symtab_node_encoder
);
3096 all_file_decl_data
[i
]->symtab_node_encoder
= NULL
;
3097 lto_free_function_in_decl_state (all_file_decl_data
[i
]->global_decl_state
);
3098 all_file_decl_data
[i
]->global_decl_state
= NULL
;
3099 all_file_decl_data
[i
]->current_decl_state
= NULL
;
3102 /* Finally merge the cgraph according to the decl merging decisions. */
3103 timevar_push (TV_IPA_LTO_CGRAPH_MERGE
);
3104 if (symtab
->dump_file
)
3106 fprintf (symtab
->dump_file
, "Before merging:\n");
3107 symtab_node::dump_table (symtab
->dump_file
);
3109 lto_symtab_merge_symbols ();
3110 /* Removal of unreachable symbols is needed to make verify_symtab to pass;
3111 we are still having duplicated comdat groups containing local statics.
3112 We could also just remove them while merging. */
3113 symtab
->remove_unreachable_nodes (dump_file
);
3115 symtab
->state
= IPA_SSA
;
3117 timevar_pop (TV_IPA_LTO_CGRAPH_MERGE
);
3119 /* Indicate that the cgraph is built and ready. */
3120 symtab
->function_flags_ready
= true;
3122 ggc_free (all_file_decl_data
);
3123 all_file_decl_data
= NULL
;
3127 /* Materialize all the bodies for all the nodes in the callgraph. */
3130 materialize_cgraph (void)
3132 struct cgraph_node
*node
;
3133 timevar_id_t lto_timer
;
3137 flag_wpa
? "Materializing decls:" : "Reading function bodies:");
3140 FOR_EACH_FUNCTION (node
)
3142 if (node
->lto_file_data
)
3144 lto_materialize_function (node
);
3145 lto_stats
.num_input_cgraph_nodes
++;
3150 /* Start the appropriate timer depending on the mode that we are
3152 lto_timer
= (flag_wpa
) ? TV_WHOPR_WPA
3153 : (flag_ltrans
) ? TV_WHOPR_LTRANS
3155 timevar_push (lto_timer
);
3157 current_function_decl
= NULL
;
3161 fprintf (stderr
, "\n");
3163 timevar_pop (lto_timer
);
3167 /* Show various memory usage statistics related to LTO. */
3169 print_lto_report_1 (void)
3171 const char *pfx
= (flag_lto
) ? "LTO" : (flag_wpa
) ? "WPA" : "LTRANS";
3172 fprintf (stderr
, "%s statistics\n", pfx
);
3174 fprintf (stderr
, "[%s] read %lu SCCs of average size %f\n",
3175 pfx
, num_sccs_read
, total_scc_size
/ (double)num_sccs_read
);
3176 fprintf (stderr
, "[%s] %lu tree bodies read in total\n", pfx
, total_scc_size
);
3177 if (flag_wpa
&& tree_scc_hash
)
3179 fprintf (stderr
, "[%s] tree SCC table: size %ld, %ld elements, "
3180 "collision ratio: %f\n", pfx
,
3181 (long) tree_scc_hash
->size (),
3182 (long) tree_scc_hash
->elements (),
3183 tree_scc_hash
->collisions ());
3184 hash_table
<tree_scc_hasher
>::iterator hiter
;
3185 tree_scc
*scc
, *max_scc
= NULL
;
3186 unsigned max_length
= 0;
3187 FOR_EACH_HASH_TABLE_ELEMENT (*tree_scc_hash
, scc
, x
, hiter
)
3189 unsigned length
= 0;
3191 for (; s
; s
= s
->next
)
3193 if (length
> max_length
)
3195 max_length
= length
;
3199 fprintf (stderr
, "[%s] tree SCC max chain length %u (size %u)\n",
3200 pfx
, max_length
, max_scc
->len
);
3201 fprintf (stderr
, "[%s] Compared %lu SCCs, %lu collisions (%f)\n", pfx
,
3202 num_scc_compares
, num_scc_compare_collisions
,
3203 num_scc_compare_collisions
/ (double) num_scc_compares
);
3204 fprintf (stderr
, "[%s] Merged %lu SCCs\n", pfx
, num_sccs_merged
);
3205 fprintf (stderr
, "[%s] Merged %lu tree bodies\n", pfx
,
3206 total_scc_size_merged
);
3207 fprintf (stderr
, "[%s] Merged %lu types\n", pfx
, num_merged_types
);
3208 fprintf (stderr
, "[%s] %lu types prevailed (%lu associated trees)\n",
3209 pfx
, num_prevailing_types
, num_type_scc_trees
);
3210 fprintf (stderr
, "[%s] GIMPLE canonical type table: size %ld, "
3211 "%ld elements, %ld searches, %ld collisions (ratio: %f)\n", pfx
,
3212 (long) htab_size (gimple_canonical_types
),
3213 (long) htab_elements (gimple_canonical_types
),
3214 (long) gimple_canonical_types
->searches
,
3215 (long) gimple_canonical_types
->collisions
,
3216 htab_collisions (gimple_canonical_types
));
3217 fprintf (stderr
, "[%s] GIMPLE canonical type pointer-map: "
3218 "%lu elements, %ld searches\n", pfx
,
3219 num_canonical_type_hash_entries
,
3220 num_canonical_type_hash_queries
);
3223 print_lto_report (pfx
);
3226 /* Perform whole program analysis (WPA) on the callgraph and write out the
3227 optimization plan. */
3230 do_whole_program_analysis (void)
3234 lto_parallelism
= 1;
3236 /* TODO: jobserver communicatoin is not supported, yet. */
3237 if (!strcmp (flag_wpa
, "jobserver"))
3238 lto_parallelism
= -1;
3241 lto_parallelism
= atoi (flag_wpa
);
3242 if (lto_parallelism
<= 0)
3243 lto_parallelism
= 0;
3246 timevar_start (TV_PHASE_OPT_GEN
);
3248 /* Note that since we are in WPA mode, materialize_cgraph will not
3249 actually read in all the function bodies. It only materializes
3250 the decls and cgraph nodes so that analysis can be performed. */
3251 materialize_cgraph ();
3253 /* Reading in the cgraph uses different timers, start timing WPA now. */
3254 timevar_push (TV_WHOPR_WPA
);
3256 if (pre_ipa_mem_report
)
3258 fprintf (stderr
, "Memory consumption before IPA\n");
3259 dump_memory_report (false);
3262 symtab
->function_flags_ready
= true;
3264 if (symtab
->dump_file
)
3265 symtab_node::dump_table (symtab
->dump_file
);
3266 bitmap_obstack_initialize (NULL
);
3267 symtab
->state
= IPA_SSA
;
3269 execute_ipa_pass_list (g
->get_passes ()->all_regular_ipa_passes
);
3271 if (symtab
->dump_file
)
3273 fprintf (symtab
->dump_file
, "Optimized ");
3274 symtab_node::dump_table (symtab
->dump_file
);
3276 #ifdef ENABLE_CHECKING
3277 symtab_node::verify_symtab_nodes ();
3279 bitmap_obstack_release (NULL
);
3281 /* We are about to launch the final LTRANS phase, stop the WPA timer. */
3282 timevar_pop (TV_WHOPR_WPA
);
3284 timevar_push (TV_WHOPR_PARTITIONING
);
3285 if (flag_lto_partition
== LTO_PARTITION_1TO1
)
3287 else if (flag_lto_partition
== LTO_PARTITION_MAX
)
3289 else if (flag_lto_partition
== LTO_PARTITION_ONE
)
3290 lto_balanced_map (1);
3291 else if (flag_lto_partition
== LTO_PARTITION_BALANCED
)
3292 lto_balanced_map (PARAM_VALUE (PARAM_LTO_PARTITIONS
));
3296 /* Inline summaries are needed for balanced partitioning. Free them now so
3297 the memory can be used for streamer caches. */
3298 inline_free_summary ();
3300 /* AUX pointers are used by partitioning code to bookkeep number of
3301 partitions symbol is in. This is no longer needed. */
3302 FOR_EACH_SYMBOL (node
)
3305 lto_stats
.num_cgraph_partitions
+= ltrans_partitions
.length ();
3307 /* Find out statics that need to be promoted
3308 to globals with hidden visibility because they are accessed from multiple
3310 lto_promote_cross_file_statics ();
3311 timevar_pop (TV_WHOPR_PARTITIONING
);
3313 timevar_stop (TV_PHASE_OPT_GEN
);
3315 /* Collect a last time - in lto_wpa_write_files we may end up forking
3316 with the idea that this doesn't increase memory usage. So we
3317 absoultely do not want to collect after that. */
3320 timevar_start (TV_PHASE_STREAM_OUT
);
3323 fprintf (stderr
, "\nStreaming out");
3326 lto_wpa_write_files ();
3328 fprintf (stderr
, "\n");
3329 timevar_stop (TV_PHASE_STREAM_OUT
);
3331 if (post_ipa_mem_report
)
3333 fprintf (stderr
, "Memory consumption after IPA\n");
3334 dump_memory_report (false);
3337 /* Show the LTO report before launching LTRANS. */
3338 if (flag_lto_report
|| (flag_wpa
&& flag_lto_report_wpa
))
3339 print_lto_report_1 ();
3341 dump_memory_report (true);
3345 static GTY(()) tree lto_eh_personality_decl
;
3347 /* Return the LTO personality function decl. */
3350 lto_eh_personality (void)
3352 if (!lto_eh_personality_decl
)
3354 /* Use the first personality DECL for our personality if we don't
3355 support multiple ones. This ensures that we don't artificially
3356 create the need for them in a single-language program. */
3357 if (first_personality_decl
&& !dwarf2out_do_cfi_asm ())
3358 lto_eh_personality_decl
= first_personality_decl
;
3360 lto_eh_personality_decl
= lhd_gcc_personality ();
3363 return lto_eh_personality_decl
;
3366 /* Set the process name based on the LTO mode. */
3369 lto_process_name (void)
3372 setproctitle ("lto1-lto");
3374 setproctitle ("lto1-wpa");
3376 setproctitle ("lto1-ltrans");
3380 /* Initialize the LTO front end. */
3385 lto_process_name ();
3386 lto_streamer_hooks_init ();
3388 lto_set_in_hooks (NULL
, get_section_data
, free_section_data
);
3389 memset (<o_stats
, 0, sizeof (lto_stats
));
3390 bitmap_obstack_initialize (NULL
);
3391 gimple_register_cfg_hooks ();
3395 /* Main entry point for the GIMPLE front end. This front end has
3396 three main personalities:
3398 - LTO (-flto). All the object files on the command line are
3399 loaded in memory and processed as a single translation unit.
3400 This is the traditional link-time optimization behavior.
3402 - WPA (-fwpa). Only the callgraph and summary information for
3403 files in the command file are loaded. A single callgraph
3404 (without function bodies) is instantiated for the whole set of
3405 files. IPA passes are only allowed to analyze the call graph
3406 and make transformation decisions. The callgraph is
3407 partitioned, each partition is written to a new object file
3408 together with the transformation decisions.
3410 - LTRANS (-fltrans). Similar to -flto but it prevents the IPA
3411 summary files from running again. Since WPA computed summary
3412 information and decided what transformations to apply, LTRANS
3413 simply applies them. */
3418 /* LTO is called as a front end, even though it is not a front end.
3419 Because it is called as a front end, TV_PHASE_PARSING and
3420 TV_PARSE_GLOBAL are active, and we need to turn them off while
3421 doing LTO. Later we turn them back on so they are active up in
3423 timevar_pop (TV_PARSE_GLOBAL
);
3424 timevar_stop (TV_PHASE_PARSING
);
3426 timevar_start (TV_PHASE_SETUP
);
3428 /* Initialize the LTO front end. */
3431 timevar_stop (TV_PHASE_SETUP
);
3432 timevar_start (TV_PHASE_STREAM_IN
);
3434 /* Read all the symbols and call graph from all the files in the
3436 read_cgraph_and_symbols (num_in_fnames
, in_fnames
);
3438 timevar_stop (TV_PHASE_STREAM_IN
);
3442 /* If WPA is enabled analyze the whole call graph and create an
3443 optimization plan. Otherwise, read in all the function
3444 bodies and continue with optimization. */
3446 do_whole_program_analysis ();
3449 timevar_start (TV_PHASE_OPT_GEN
);
3451 materialize_cgraph ();
3453 lto_promote_statics_nonwpa ();
3455 /* Let the middle end know that we have read and merged all of
3459 timevar_stop (TV_PHASE_OPT_GEN
);
3461 /* FIXME lto, if the processes spawned by WPA fail, we miss
3462 the chance to print WPA's report, so WPA will call
3463 print_lto_report before launching LTRANS. If LTRANS was
3464 launched directly by the driver we would not need to do
3466 if (flag_lto_report
|| (flag_wpa
&& flag_lto_report_wpa
))
3467 print_lto_report_1 ();
3471 /* Here we make LTO pretend to be a parser. */
3472 timevar_start (TV_PHASE_PARSING
);
3473 timevar_push (TV_PARSE_GLOBAL
);
3476 #include "gt-lto-lto.h"