1 /* Top-level LTO routines.
2 Copyright (C) 2009-2013 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"
27 #include "stor-layout.h"
28 #include "diagnostic-core.h"
31 #include "tree-ssa-operands.h"
32 #include "tree-pass.h"
33 #include "langhooks.h"
38 #include "tree-ssa-alias.h"
39 #include "internal-fn.h"
40 #include "gimple-expr.h"
45 #include "lto-streamer.h"
46 #include "tree-streamer.h"
47 #include "splay-tree.h"
48 #include "lto-partition.h"
49 #include "data-streamer.h"
51 #include "pass_manager.h"
53 /* Vector to keep track of external variables we've seen so far. */
54 vec
<tree
, va_gc
> *lto_global_var_decls
;
56 static GTY(()) tree first_personality_decl
;
58 /* Returns a hash code for P. */
61 hash_name (const void *p
)
63 const struct lto_section_slot
*ds
= (const struct lto_section_slot
*) p
;
64 return (hashval_t
) htab_hash_string (ds
->name
);
68 /* Returns nonzero if P1 and P2 are equal. */
71 eq_name (const void *p1
, const void *p2
)
73 const struct lto_section_slot
*s1
=
74 (const struct lto_section_slot
*) p1
;
75 const struct lto_section_slot
*s2
=
76 (const struct lto_section_slot
*) p2
;
78 return strcmp (s1
->name
, s2
->name
) == 0;
81 /* Free lto_section_slot */
84 free_with_string (void *arg
)
86 struct lto_section_slot
*s
= (struct lto_section_slot
*)arg
;
88 free (CONST_CAST (char *, s
->name
));
92 /* Create section hash table */
95 lto_obj_create_section_hash_table (void)
97 return htab_create (37, hash_name
, eq_name
, free_with_string
);
100 /* Delete an allocated integer KEY in the splay tree. */
103 lto_splay_tree_delete_id (splay_tree_key key
)
108 /* Compare splay tree node ids A and B. */
111 lto_splay_tree_compare_ids (splay_tree_key a
, splay_tree_key b
)
113 unsigned HOST_WIDE_INT ai
;
114 unsigned HOST_WIDE_INT bi
;
116 ai
= *(unsigned HOST_WIDE_INT
*) a
;
117 bi
= *(unsigned HOST_WIDE_INT
*) b
;
126 /* Look up splay tree node by ID in splay tree T. */
128 static splay_tree_node
129 lto_splay_tree_lookup (splay_tree t
, unsigned HOST_WIDE_INT id
)
131 return splay_tree_lookup (t
, (splay_tree_key
) &id
);
134 /* Check if KEY has ID. */
137 lto_splay_tree_id_equal_p (splay_tree_key key
, unsigned HOST_WIDE_INT id
)
139 return *(unsigned HOST_WIDE_INT
*) key
== id
;
142 /* Insert a splay tree node into tree T with ID as key and FILE_DATA as value.
143 The ID is allocated separately because we need HOST_WIDE_INTs which may
144 be wider than a splay_tree_key. */
147 lto_splay_tree_insert (splay_tree t
, unsigned HOST_WIDE_INT id
,
148 struct lto_file_decl_data
*file_data
)
150 unsigned HOST_WIDE_INT
*idp
= XCNEW (unsigned HOST_WIDE_INT
);
152 splay_tree_insert (t
, (splay_tree_key
) idp
, (splay_tree_value
) file_data
);
155 /* Create a splay tree. */
158 lto_splay_tree_new (void)
160 return splay_tree_new (lto_splay_tree_compare_ids
,
161 lto_splay_tree_delete_id
,
165 /* Return true when NODE has a clone that is analyzed (i.e. we need
166 to load its body even if the node itself is not needed). */
169 has_analyzed_clone_p (struct cgraph_node
*node
)
171 struct cgraph_node
*orig
= node
;
180 else if (node
->next_sibling_clone
)
181 node
= node
->next_sibling_clone
;
184 while (node
!= orig
&& !node
->next_sibling_clone
)
185 node
= node
->clone_of
;
187 node
= node
->next_sibling_clone
;
193 /* Read the function body for the function associated with NODE. */
196 lto_materialize_function (struct cgraph_node
*node
)
201 /* Read in functions with body (analyzed nodes)
202 and also functions that are needed to produce virtual clones. */
203 if ((cgraph_function_with_gimple_body_p (node
) && node
->analyzed
)
204 || node
->used_as_abstract_origin
205 || has_analyzed_clone_p (node
))
207 /* Clones don't need to be read. */
210 if (DECL_FUNCTION_PERSONALITY (decl
) && !first_personality_decl
)
211 first_personality_decl
= DECL_FUNCTION_PERSONALITY (decl
);
214 /* Let the middle end know about the function. */
215 rest_of_decl_compilation (decl
, 1, 0);
219 /* Decode the content of memory pointed to by DATA in the in decl
220 state object STATE. DATA_IN points to a data_in structure for
221 decoding. Return the address after the decoded object in the
224 static const uint32_t *
225 lto_read_in_decl_state (struct data_in
*data_in
, const uint32_t *data
,
226 struct lto_in_decl_state
*state
)
233 decl
= streamer_tree_cache_get_tree (data_in
->reader_cache
, ix
);
234 if (TREE_CODE (decl
) != FUNCTION_DECL
)
236 gcc_assert (decl
== void_type_node
);
239 state
->fn_decl
= decl
;
241 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
243 uint32_t size
= *data
++;
244 tree
*decls
= ggc_alloc_vec_tree (size
);
246 for (j
= 0; j
< size
; j
++)
247 decls
[j
] = streamer_tree_cache_get_tree (data_in
->reader_cache
, data
[j
]);
249 state
->streams
[i
].size
= size
;
250 state
->streams
[i
].trees
= decls
;
258 /* Global canonical type table. */
259 static htab_t gimple_canonical_types
;
260 static pointer_map
<hashval_t
> *canonical_type_hash_cache
;
261 static unsigned long num_canonical_type_hash_entries
;
262 static unsigned long num_canonical_type_hash_queries
;
264 static hashval_t
iterative_hash_canonical_type (tree type
, hashval_t val
);
265 static hashval_t
gimple_canonical_type_hash (const void *p
);
266 static void gimple_register_canonical_type_1 (tree t
, hashval_t hash
);
268 /* Returning a hash value for gimple type TYPE.
270 The hash value returned is equal for types considered compatible
271 by gimple_canonical_types_compatible_p. */
274 hash_canonical_type (tree type
)
278 /* Combine a few common features of types so that types are grouped into
279 smaller sets; when searching for existing matching types to merge,
280 only existing types having the same features as the new type will be
282 v
= iterative_hash_hashval_t (TREE_CODE (type
), 0);
283 v
= iterative_hash_hashval_t (TREE_ADDRESSABLE (type
), v
);
284 v
= iterative_hash_hashval_t (TYPE_ALIGN (type
), v
);
285 v
= iterative_hash_hashval_t (TYPE_MODE (type
), v
);
287 /* Incorporate common features of numerical types. */
288 if (INTEGRAL_TYPE_P (type
)
289 || SCALAR_FLOAT_TYPE_P (type
)
290 || FIXED_POINT_TYPE_P (type
)
291 || TREE_CODE (type
) == OFFSET_TYPE
292 || POINTER_TYPE_P (type
))
294 v
= iterative_hash_hashval_t (TYPE_PRECISION (type
), v
);
295 v
= iterative_hash_hashval_t (TYPE_UNSIGNED (type
), v
);
298 if (VECTOR_TYPE_P (type
))
300 v
= iterative_hash_hashval_t (TYPE_VECTOR_SUBPARTS (type
), v
);
301 v
= iterative_hash_hashval_t (TYPE_UNSIGNED (type
), v
);
304 if (TREE_CODE (type
) == COMPLEX_TYPE
)
305 v
= iterative_hash_hashval_t (TYPE_UNSIGNED (type
), v
);
307 /* For pointer and reference types, fold in information about the type
308 pointed to but do not recurse to the pointed-to type. */
309 if (POINTER_TYPE_P (type
))
311 v
= iterative_hash_hashval_t (TYPE_REF_CAN_ALIAS_ALL (type
), v
);
312 v
= iterative_hash_hashval_t (TYPE_ADDR_SPACE (TREE_TYPE (type
)), v
);
313 v
= iterative_hash_hashval_t (TYPE_RESTRICT (type
), v
);
314 v
= iterative_hash_hashval_t (TREE_CODE (TREE_TYPE (type
)), v
);
317 /* For integer types hash only the string flag. */
318 if (TREE_CODE (type
) == INTEGER_TYPE
)
319 v
= iterative_hash_hashval_t (TYPE_STRING_FLAG (type
), v
);
321 /* For array types hash the domain bounds and the string flag. */
322 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
324 v
= iterative_hash_hashval_t (TYPE_STRING_FLAG (type
), v
);
325 /* OMP lowering can introduce error_mark_node in place of
326 random local decls in types. */
327 if (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)) != error_mark_node
)
328 v
= iterative_hash_expr (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)), v
);
329 if (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != error_mark_node
)
330 v
= iterative_hash_expr (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)), v
);
333 /* Recurse for aggregates with a single element type. */
334 if (TREE_CODE (type
) == ARRAY_TYPE
335 || TREE_CODE (type
) == COMPLEX_TYPE
336 || TREE_CODE (type
) == VECTOR_TYPE
)
337 v
= iterative_hash_canonical_type (TREE_TYPE (type
), v
);
339 /* Incorporate function return and argument types. */
340 if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
345 /* For method types also incorporate their parent class. */
346 if (TREE_CODE (type
) == METHOD_TYPE
)
347 v
= iterative_hash_canonical_type (TYPE_METHOD_BASETYPE (type
), v
);
349 v
= iterative_hash_canonical_type (TREE_TYPE (type
), v
);
351 for (p
= TYPE_ARG_TYPES (type
), na
= 0; p
; p
= TREE_CHAIN (p
))
353 v
= iterative_hash_canonical_type (TREE_VALUE (p
), v
);
357 v
= iterative_hash_hashval_t (na
, v
);
360 if (RECORD_OR_UNION_TYPE_P (type
))
365 for (f
= TYPE_FIELDS (type
), nf
= 0; f
; f
= TREE_CHAIN (f
))
366 if (TREE_CODE (f
) == FIELD_DECL
)
368 v
= iterative_hash_canonical_type (TREE_TYPE (f
), v
);
372 v
= iterative_hash_hashval_t (nf
, v
);
378 /* Returning a hash value for gimple type TYPE combined with VAL. */
381 iterative_hash_canonical_type (tree type
, hashval_t val
)
384 /* An already processed type. */
385 if (TYPE_CANONICAL (type
))
387 type
= TYPE_CANONICAL (type
);
388 v
= gimple_canonical_type_hash (type
);
392 /* Canonical types should not be able to form SCCs by design, this
393 recursion is just because we do not register canonical types in
394 optimal order. To avoid quadratic behavior also register the
396 v
= hash_canonical_type (type
);
397 gimple_register_canonical_type_1 (type
, v
);
399 return iterative_hash_hashval_t (v
, val
);
402 /* Returns the hash for a canonical type P. */
405 gimple_canonical_type_hash (const void *p
)
407 num_canonical_type_hash_queries
++;
409 = canonical_type_hash_cache
->contains (CONST_CAST_TREE ((const_tree
) p
));
410 gcc_assert (slot
!= NULL
);
415 /* The TYPE_CANONICAL merging machinery. It should closely resemble
416 the middle-end types_compatible_p function. It needs to avoid
417 claiming types are different for types that should be treated
418 the same with respect to TBAA. Canonical types are also used
419 for IL consistency checks via the useless_type_conversion_p
420 predicate which does not handle all type kinds itself but falls
421 back to pointer-comparison of TYPE_CANONICAL for aggregates
424 /* Return true iff T1 and T2 are structurally identical for what
425 TBAA is concerned. */
428 gimple_canonical_types_compatible_p (tree t1
, tree t2
)
430 /* Before starting to set up the SCC machinery handle simple cases. */
432 /* Check first for the obvious case of pointer identity. */
436 /* Check that we have two types to compare. */
437 if (t1
== NULL_TREE
|| t2
== NULL_TREE
)
440 /* If the types have been previously registered and found equal
442 if (TYPE_CANONICAL (t1
)
443 && TYPE_CANONICAL (t1
) == TYPE_CANONICAL (t2
))
446 /* Can't be the same type if the types don't have the same code. */
447 if (TREE_CODE (t1
) != TREE_CODE (t2
))
450 if (TREE_ADDRESSABLE (t1
) != TREE_ADDRESSABLE (t2
))
453 /* Qualifiers do not matter for canonical type comparison purposes. */
455 /* Void types and nullptr types are always the same. */
456 if (TREE_CODE (t1
) == VOID_TYPE
457 || TREE_CODE (t1
) == NULLPTR_TYPE
)
460 /* Can't be the same type if they have different alignment, or mode. */
461 if (TYPE_ALIGN (t1
) != TYPE_ALIGN (t2
)
462 || TYPE_MODE (t1
) != TYPE_MODE (t2
))
465 /* Non-aggregate types can be handled cheaply. */
466 if (INTEGRAL_TYPE_P (t1
)
467 || SCALAR_FLOAT_TYPE_P (t1
)
468 || FIXED_POINT_TYPE_P (t1
)
469 || TREE_CODE (t1
) == VECTOR_TYPE
470 || TREE_CODE (t1
) == COMPLEX_TYPE
471 || TREE_CODE (t1
) == OFFSET_TYPE
472 || POINTER_TYPE_P (t1
))
474 /* Can't be the same type if they have different sign or precision. */
475 if (TYPE_PRECISION (t1
) != TYPE_PRECISION (t2
)
476 || TYPE_UNSIGNED (t1
) != TYPE_UNSIGNED (t2
))
479 if (TREE_CODE (t1
) == INTEGER_TYPE
480 && TYPE_STRING_FLAG (t1
) != TYPE_STRING_FLAG (t2
))
483 /* For canonical type comparisons we do not want to build SCCs
484 so we cannot compare pointed-to types. But we can, for now,
485 require the same pointed-to type kind and match what
486 useless_type_conversion_p would do. */
487 if (POINTER_TYPE_P (t1
))
489 /* If the two pointers have different ref-all attributes,
490 they can't be the same type. */
491 if (TYPE_REF_CAN_ALIAS_ALL (t1
) != TYPE_REF_CAN_ALIAS_ALL (t2
))
494 if (TYPE_ADDR_SPACE (TREE_TYPE (t1
))
495 != TYPE_ADDR_SPACE (TREE_TYPE (t2
)))
498 if (TYPE_RESTRICT (t1
) != TYPE_RESTRICT (t2
))
501 if (TREE_CODE (TREE_TYPE (t1
)) != TREE_CODE (TREE_TYPE (t2
)))
505 /* Tail-recurse to components. */
506 if (TREE_CODE (t1
) == VECTOR_TYPE
507 || TREE_CODE (t1
) == COMPLEX_TYPE
)
508 return gimple_canonical_types_compatible_p (TREE_TYPE (t1
),
514 /* Do type-specific comparisons. */
515 switch (TREE_CODE (t1
))
518 /* Array types are the same if the element types are the same and
519 the number of elements are the same. */
520 if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1
), TREE_TYPE (t2
))
521 || TYPE_STRING_FLAG (t1
) != TYPE_STRING_FLAG (t2
)
522 || TYPE_NONALIASED_COMPONENT (t1
) != TYPE_NONALIASED_COMPONENT (t2
))
526 tree i1
= TYPE_DOMAIN (t1
);
527 tree i2
= TYPE_DOMAIN (t2
);
529 /* For an incomplete external array, the type domain can be
530 NULL_TREE. Check this condition also. */
531 if (i1
== NULL_TREE
&& i2
== NULL_TREE
)
533 else if (i1
== NULL_TREE
|| i2
== NULL_TREE
)
537 tree min1
= TYPE_MIN_VALUE (i1
);
538 tree min2
= TYPE_MIN_VALUE (i2
);
539 tree max1
= TYPE_MAX_VALUE (i1
);
540 tree max2
= TYPE_MAX_VALUE (i2
);
542 /* The minimum/maximum values have to be the same. */
545 && ((TREE_CODE (min1
) == PLACEHOLDER_EXPR
546 && TREE_CODE (min2
) == PLACEHOLDER_EXPR
)
547 || operand_equal_p (min1
, min2
, 0))))
550 && ((TREE_CODE (max1
) == PLACEHOLDER_EXPR
551 && TREE_CODE (max2
) == PLACEHOLDER_EXPR
)
552 || operand_equal_p (max1
, max2
, 0)))))
561 /* Function types are the same if the return type and arguments types
563 if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
566 if (!comp_type_attributes (t1
, t2
))
569 if (TYPE_ARG_TYPES (t1
) == TYPE_ARG_TYPES (t2
))
575 for (parms1
= TYPE_ARG_TYPES (t1
), parms2
= TYPE_ARG_TYPES (t2
);
577 parms1
= TREE_CHAIN (parms1
), parms2
= TREE_CHAIN (parms2
))
579 if (!gimple_canonical_types_compatible_p
580 (TREE_VALUE (parms1
), TREE_VALUE (parms2
)))
584 if (parms1
|| parms2
)
592 case QUAL_UNION_TYPE
:
596 /* For aggregate types, all the fields must be the same. */
597 for (f1
= TYPE_FIELDS (t1
), f2
= TYPE_FIELDS (t2
);
599 f1
= TREE_CHAIN (f1
), f2
= TREE_CHAIN (f2
))
601 /* Skip non-fields. */
602 while (f1
&& TREE_CODE (f1
) != FIELD_DECL
)
603 f1
= TREE_CHAIN (f1
);
604 while (f2
&& TREE_CODE (f2
) != FIELD_DECL
)
605 f2
= TREE_CHAIN (f2
);
608 /* The fields must have the same name, offset and type. */
609 if (DECL_NONADDRESSABLE_P (f1
) != DECL_NONADDRESSABLE_P (f2
)
610 || !gimple_compare_field_offset (f1
, f2
)
611 || !gimple_canonical_types_compatible_p
612 (TREE_TYPE (f1
), TREE_TYPE (f2
)))
616 /* If one aggregate has more fields than the other, they
630 /* Returns nonzero if P1 and P2 are equal. */
633 gimple_canonical_type_eq (const void *p1
, const void *p2
)
635 const_tree t1
= (const_tree
) p1
;
636 const_tree t2
= (const_tree
) p2
;
637 return gimple_canonical_types_compatible_p (CONST_CAST_TREE (t1
),
638 CONST_CAST_TREE (t2
));
641 /* Main worker for gimple_register_canonical_type. */
644 gimple_register_canonical_type_1 (tree t
, hashval_t hash
)
648 gcc_checking_assert (TYPE_P (t
) && !TYPE_CANONICAL (t
));
650 slot
= htab_find_slot_with_hash (gimple_canonical_types
, t
, hash
, INSERT
);
653 tree new_type
= (tree
)(*slot
);
654 gcc_checking_assert (new_type
!= t
);
655 TYPE_CANONICAL (t
) = new_type
;
659 TYPE_CANONICAL (t
) = t
;
661 /* Cache the just computed hash value. */
662 num_canonical_type_hash_entries
++;
664 hashval_t
*hslot
= canonical_type_hash_cache
->insert (t
, &existed_p
);
665 gcc_assert (!existed_p
);
670 /* Register type T in the global type table gimple_types and set
671 TYPE_CANONICAL of T accordingly.
672 This is used by LTO to merge structurally equivalent types for
673 type-based aliasing purposes across different TUs and languages.
675 ??? This merging does not exactly match how the tree.c middle-end
676 functions will assign TYPE_CANONICAL when new types are created
677 during optimization (which at least happens for pointer and array
681 gimple_register_canonical_type (tree t
)
683 if (TYPE_CANONICAL (t
))
686 gimple_register_canonical_type_1 (t
, hash_canonical_type (t
));
689 /* Re-compute TYPE_CANONICAL for NODE and related types. */
692 lto_register_canonical_types (tree node
, bool first_p
)
699 TYPE_CANONICAL (node
) = NULL_TREE
;
701 if (POINTER_TYPE_P (node
)
702 || TREE_CODE (node
) == COMPLEX_TYPE
703 || TREE_CODE (node
) == ARRAY_TYPE
)
704 lto_register_canonical_types (TREE_TYPE (node
), first_p
);
707 gimple_register_canonical_type (node
);
711 /* Remember trees that contains references to declarations. */
712 static GTY(()) vec
<tree
, va_gc
> *tree_with_vars
;
714 #define CHECK_VAR(tt) \
717 if ((tt) && VAR_OR_FUNCTION_DECL_P (tt) \
718 && (TREE_PUBLIC (tt) || DECL_EXTERNAL (tt))) \
722 #define CHECK_NO_VAR(tt) \
723 gcc_checking_assert (!(tt) || !VAR_OR_FUNCTION_DECL_P (tt))
725 /* Check presence of pointers to decls in fields of a tree_typed T. */
728 mentions_vars_p_typed (tree t
)
730 CHECK_NO_VAR (TREE_TYPE (t
));
734 /* Check presence of pointers to decls in fields of a tree_common T. */
737 mentions_vars_p_common (tree t
)
739 if (mentions_vars_p_typed (t
))
741 CHECK_NO_VAR (TREE_CHAIN (t
));
745 /* Check presence of pointers to decls in fields of a decl_minimal T. */
748 mentions_vars_p_decl_minimal (tree t
)
750 if (mentions_vars_p_common (t
))
752 CHECK_NO_VAR (DECL_NAME (t
));
753 CHECK_VAR (DECL_CONTEXT (t
));
757 /* Check presence of pointers to decls in fields of a decl_common T. */
760 mentions_vars_p_decl_common (tree t
)
762 if (mentions_vars_p_decl_minimal (t
))
764 CHECK_VAR (DECL_SIZE (t
));
765 CHECK_VAR (DECL_SIZE_UNIT (t
));
766 CHECK_VAR (DECL_INITIAL (t
));
767 CHECK_NO_VAR (DECL_ATTRIBUTES (t
));
768 CHECK_VAR (DECL_ABSTRACT_ORIGIN (t
));
772 /* Check presence of pointers to decls in fields of a decl_with_vis T. */
775 mentions_vars_p_decl_with_vis (tree t
)
777 if (mentions_vars_p_decl_common (t
))
780 /* Accessor macro has side-effects, use field-name here. */
781 CHECK_NO_VAR (t
->decl_with_vis
.assembler_name
);
782 CHECK_NO_VAR (DECL_SECTION_NAME (t
));
786 /* Check presence of pointers to decls in fields of a decl_non_common T. */
789 mentions_vars_p_decl_non_common (tree t
)
791 if (mentions_vars_p_decl_with_vis (t
))
793 CHECK_NO_VAR (DECL_ARGUMENT_FLD (t
));
794 CHECK_NO_VAR (DECL_RESULT_FLD (t
));
795 CHECK_NO_VAR (DECL_VINDEX (t
));
799 /* Check presence of pointers to decls in fields of a decl_non_common T. */
802 mentions_vars_p_function (tree t
)
804 if (mentions_vars_p_decl_non_common (t
))
806 CHECK_VAR (DECL_FUNCTION_PERSONALITY (t
));
810 /* Check presence of pointers to decls in fields of a field_decl T. */
813 mentions_vars_p_field_decl (tree t
)
815 if (mentions_vars_p_decl_common (t
))
817 CHECK_VAR (DECL_FIELD_OFFSET (t
));
818 CHECK_NO_VAR (DECL_BIT_FIELD_TYPE (t
));
819 CHECK_NO_VAR (DECL_QUALIFIER (t
));
820 CHECK_NO_VAR (DECL_FIELD_BIT_OFFSET (t
));
821 CHECK_NO_VAR (DECL_FCONTEXT (t
));
825 /* Check presence of pointers to decls in fields of a type T. */
828 mentions_vars_p_type (tree t
)
830 if (mentions_vars_p_common (t
))
832 CHECK_NO_VAR (TYPE_CACHED_VALUES (t
));
833 CHECK_VAR (TYPE_SIZE (t
));
834 CHECK_VAR (TYPE_SIZE_UNIT (t
));
835 CHECK_NO_VAR (TYPE_ATTRIBUTES (t
));
836 CHECK_NO_VAR (TYPE_NAME (t
));
838 CHECK_VAR (TYPE_MINVAL (t
));
839 CHECK_VAR (TYPE_MAXVAL (t
));
841 /* Accessor is for derived node types only. */
842 CHECK_NO_VAR (t
->type_non_common
.binfo
);
844 CHECK_VAR (TYPE_CONTEXT (t
));
845 CHECK_NO_VAR (TYPE_CANONICAL (t
));
846 CHECK_NO_VAR (TYPE_MAIN_VARIANT (t
));
847 CHECK_NO_VAR (TYPE_NEXT_VARIANT (t
));
851 /* Check presence of pointers to decls in fields of a BINFO T. */
854 mentions_vars_p_binfo (tree t
)
856 unsigned HOST_WIDE_INT i
, n
;
858 if (mentions_vars_p_common (t
))
860 CHECK_VAR (BINFO_VTABLE (t
));
861 CHECK_NO_VAR (BINFO_OFFSET (t
));
862 CHECK_NO_VAR (BINFO_VIRTUALS (t
));
863 CHECK_NO_VAR (BINFO_VPTR_FIELD (t
));
864 n
= vec_safe_length (BINFO_BASE_ACCESSES (t
));
865 for (i
= 0; i
< n
; i
++)
866 CHECK_NO_VAR (BINFO_BASE_ACCESS (t
, i
));
867 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
868 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
869 n
= BINFO_N_BASE_BINFOS (t
);
870 for (i
= 0; i
< n
; i
++)
871 CHECK_NO_VAR (BINFO_BASE_BINFO (t
, i
));
875 /* Check presence of pointers to decls in fields of a CONSTRUCTOR T. */
878 mentions_vars_p_constructor (tree t
)
880 unsigned HOST_WIDE_INT idx
;
883 if (mentions_vars_p_typed (t
))
886 for (idx
= 0; vec_safe_iterate (CONSTRUCTOR_ELTS (t
), idx
, &ce
); idx
++)
888 CHECK_NO_VAR (ce
->index
);
889 CHECK_VAR (ce
->value
);
894 /* Check presence of pointers to decls in fields of an expression tree T. */
897 mentions_vars_p_expr (tree t
)
900 if (mentions_vars_p_typed (t
))
902 for (i
= TREE_OPERAND_LENGTH (t
) - 1; i
>= 0; --i
)
903 CHECK_VAR (TREE_OPERAND (t
, i
));
907 /* Check presence of pointers to decls that needs later fixup in T. */
910 mentions_vars_p (tree t
)
912 switch (TREE_CODE (t
))
914 case IDENTIFIER_NODE
:
918 CHECK_VAR (TREE_VALUE (t
));
919 CHECK_VAR (TREE_PURPOSE (t
));
920 CHECK_NO_VAR (TREE_CHAIN (t
));
924 return mentions_vars_p_field_decl (t
);
933 return mentions_vars_p_decl_common (t
);
937 return mentions_vars_p_decl_with_vis (t
);
941 return mentions_vars_p_decl_non_common (t
);
945 return mentions_vars_p_function (t
);
949 return mentions_vars_p_binfo (t
);
952 case PLACEHOLDER_EXPR
:
953 return mentions_vars_p_common (t
);
957 case TRANSLATION_UNIT_DECL
:
958 case OPTIMIZATION_NODE
:
959 case TARGET_OPTION_NODE
:
963 return mentions_vars_p_constructor (t
);
969 if (mentions_vars_p_type (t
))
974 if (mentions_vars_p_expr (t
))
977 else if (CONSTANT_CLASS_P (t
))
978 CHECK_NO_VAR (TREE_TYPE (t
));
986 /* Return the resolution for the decl with index INDEX from DATA_IN. */
988 static enum ld_plugin_symbol_resolution
989 get_resolution (struct data_in
*data_in
, unsigned index
)
991 if (data_in
->globals_resolution
.exists ())
993 ld_plugin_symbol_resolution_t ret
;
994 /* We can have references to not emitted functions in
995 DECL_FUNCTION_PERSONALITY at least. So we can and have
996 to indeed return LDPR_UNKNOWN in some cases. */
997 if (data_in
->globals_resolution
.length () <= index
)
999 ret
= data_in
->globals_resolution
[index
];
1003 /* Delay resolution finding until decl merging. */
1004 return LDPR_UNKNOWN
;
1007 /* We need to record resolutions until symbol table is read. */
1009 register_resolution (struct lto_file_decl_data
*file_data
, tree decl
,
1010 enum ld_plugin_symbol_resolution resolution
)
1012 if (resolution
== LDPR_UNKNOWN
)
1014 if (!file_data
->resolution_map
)
1015 file_data
->resolution_map
= pointer_map_create ();
1016 *pointer_map_insert (file_data
->resolution_map
, decl
) = (void *)(size_t)resolution
;
1019 /* Register DECL with the global symbol table and change its
1020 name if necessary to avoid name clashes for static globals across
1024 lto_register_var_decl_in_symtab (struct data_in
*data_in
, tree decl
,
1029 /* Variable has file scope, not local. */
1030 if (!TREE_PUBLIC (decl
)
1031 && !((context
= decl_function_context (decl
))
1032 && auto_var_in_fn_p (decl
, context
)))
1033 rest_of_decl_compilation (decl
, 1, 0);
1035 /* If this variable has already been declared, queue the
1036 declaration for merging. */
1037 if (TREE_PUBLIC (decl
))
1038 register_resolution (data_in
->file_data
,
1039 decl
, get_resolution (data_in
, ix
));
1043 /* Register DECL with the global symbol table and change its
1044 name if necessary to avoid name clashes for static globals across
1045 different files. DATA_IN contains descriptors and tables for the
1049 lto_register_function_decl_in_symtab (struct data_in
*data_in
, tree decl
,
1052 /* If this variable has already been declared, queue the
1053 declaration for merging. */
1054 if (TREE_PUBLIC (decl
) && !DECL_ABSTRACT (decl
))
1055 register_resolution (data_in
->file_data
,
1056 decl
, get_resolution (data_in
, ix
));
1060 /* For the type T re-materialize it in the type variant list and
1061 the pointer/reference-to chains. */
1064 lto_fixup_prevailing_type (tree t
)
1066 /* The following re-creates proper variant lists while fixing up
1067 the variant leaders. We do not stream TYPE_NEXT_VARIANT so the
1068 variant list state before fixup is broken. */
1070 /* If we are not our own variant leader link us into our new leaders
1072 if (TYPE_MAIN_VARIANT (t
) != t
)
1074 tree mv
= TYPE_MAIN_VARIANT (t
);
1075 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (mv
);
1076 TYPE_NEXT_VARIANT (mv
) = t
;
1079 /* The following reconstructs the pointer chains
1080 of the new pointed-to type if we are a main variant. We do
1081 not stream those so they are broken before fixup. */
1082 if (TREE_CODE (t
) == POINTER_TYPE
1083 && TYPE_MAIN_VARIANT (t
) == t
)
1085 TYPE_NEXT_PTR_TO (t
) = TYPE_POINTER_TO (TREE_TYPE (t
));
1086 TYPE_POINTER_TO (TREE_TYPE (t
)) = t
;
1088 else if (TREE_CODE (t
) == REFERENCE_TYPE
1089 && TYPE_MAIN_VARIANT (t
) == t
)
1091 TYPE_NEXT_REF_TO (t
) = TYPE_REFERENCE_TO (TREE_TYPE (t
));
1092 TYPE_REFERENCE_TO (TREE_TYPE (t
)) = t
;
1097 /* We keep prevailing tree SCCs in a hashtable with manual collision
1098 handling (in case all hashes compare the same) and keep the colliding
1099 entries in the tree_scc->next chain. */
1104 /* Hash of the whole SCC. */
1106 /* Number of trees in the SCC. */
1108 /* Number of possible entries into the SCC (tree nodes [0..entry_len-1]
1109 which share the same individual tree hash). */
1111 /* The members of the SCC.
1112 We only need to remember the first entry node candidate for prevailing
1113 SCCs (but of course have access to all entries for SCCs we are
1115 ??? For prevailing SCCs we really only need hash and the first
1116 entry candidate, but that's too awkward to implement. */
1120 struct tree_scc_hasher
: typed_noop_remove
<tree_scc
>
1122 typedef tree_scc value_type
;
1123 typedef tree_scc compare_type
;
1124 static inline hashval_t
hash (const value_type
*);
1125 static inline bool equal (const value_type
*, const compare_type
*);
1129 tree_scc_hasher::hash (const value_type
*scc
)
1135 tree_scc_hasher::equal (const value_type
*scc1
, const compare_type
*scc2
)
1137 if (scc1
->hash
!= scc2
->hash
1138 || scc1
->len
!= scc2
->len
1139 || scc1
->entry_len
!= scc2
->entry_len
)
1144 static hash_table
<tree_scc_hasher
> tree_scc_hash
;
1145 static struct obstack tree_scc_hash_obstack
;
1147 static unsigned long num_merged_types
;
1148 static unsigned long num_prevailing_types
;
1149 static unsigned long num_type_scc_trees
;
1150 static unsigned long total_scc_size
;
1151 static unsigned long num_sccs_read
;
1152 static unsigned long total_scc_size_merged
;
1153 static unsigned long num_sccs_merged
;
1154 static unsigned long num_scc_compares
;
1155 static unsigned long num_scc_compare_collisions
;
1158 /* Compare the two entries T1 and T2 of two SCCs that are possibly equal,
1159 recursing through in-SCC tree edges. Returns true if the SCCs entered
1160 through T1 and T2 are equal and fills in *MAP with the pairs of
1161 SCC entries we visited, starting with (*MAP)[0] = T1 and (*MAP)[1] = T2. */
1164 compare_tree_sccs_1 (tree t1
, tree t2
, tree
**map
)
1166 enum tree_code code
;
1168 /* Mark already visited nodes. */
1169 TREE_ASM_WRITTEN (t2
) = 1;
1171 /* Push the pair onto map. */
1176 /* Compare value-fields. */
1177 #define compare_values(X) \
1179 if (X(t1) != X(t2)) \
1183 compare_values (TREE_CODE
);
1184 code
= TREE_CODE (t1
);
1188 compare_values (TREE_SIDE_EFFECTS
);
1189 compare_values (TREE_CONSTANT
);
1190 compare_values (TREE_READONLY
);
1191 compare_values (TREE_PUBLIC
);
1193 compare_values (TREE_ADDRESSABLE
);
1194 compare_values (TREE_THIS_VOLATILE
);
1196 compare_values (DECL_UNSIGNED
);
1197 else if (TYPE_P (t1
))
1198 compare_values (TYPE_UNSIGNED
);
1200 compare_values (TYPE_ARTIFICIAL
);
1202 compare_values (TREE_NO_WARNING
);
1203 compare_values (TREE_NOTHROW
);
1204 compare_values (TREE_STATIC
);
1205 if (code
!= TREE_BINFO
)
1206 compare_values (TREE_PRIVATE
);
1207 compare_values (TREE_PROTECTED
);
1208 compare_values (TREE_DEPRECATED
);
1211 compare_values (TYPE_SATURATING
);
1212 compare_values (TYPE_ADDR_SPACE
);
1214 else if (code
== SSA_NAME
)
1215 compare_values (SSA_NAME_IS_DEFAULT_DEF
);
1217 if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
1219 compare_values (TREE_INT_CST_LOW
);
1220 compare_values (TREE_INT_CST_HIGH
);
1223 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
1225 /* ??? No suitable compare routine available. */
1226 REAL_VALUE_TYPE r1
= TREE_REAL_CST (t1
);
1227 REAL_VALUE_TYPE r2
= TREE_REAL_CST (t2
);
1229 || r1
.decimal
!= r2
.decimal
1230 || r1
.sign
!= r2
.sign
1231 || r1
.signalling
!= r2
.signalling
1232 || r1
.canonical
!= r2
.canonical
1233 || r1
.uexp
!= r2
.uexp
)
1235 for (unsigned i
= 0; i
< SIGSZ
; ++i
)
1236 if (r1
.sig
[i
] != r2
.sig
[i
])
1240 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
1241 if (!fixed_compare (EQ_EXPR
,
1242 TREE_FIXED_CST_PTR (t1
), TREE_FIXED_CST_PTR (t2
)))
1246 /* We don't want to compare locations, so there is nothing do compare
1247 for TS_DECL_MINIMAL. */
1249 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1251 compare_values (DECL_MODE
);
1252 compare_values (DECL_NONLOCAL
);
1253 compare_values (DECL_VIRTUAL_P
);
1254 compare_values (DECL_IGNORED_P
);
1255 compare_values (DECL_ABSTRACT
);
1256 compare_values (DECL_ARTIFICIAL
);
1257 compare_values (DECL_USER_ALIGN
);
1258 compare_values (DECL_PRESERVE_P
);
1259 compare_values (DECL_EXTERNAL
);
1260 compare_values (DECL_GIMPLE_REG_P
);
1261 compare_values (DECL_ALIGN
);
1262 if (code
== LABEL_DECL
)
1264 compare_values (EH_LANDING_PAD_NR
);
1265 compare_values (LABEL_DECL_UID
);
1267 else if (code
== FIELD_DECL
)
1269 compare_values (DECL_PACKED
);
1270 compare_values (DECL_NONADDRESSABLE_P
);
1271 compare_values (DECL_OFFSET_ALIGN
);
1273 else if (code
== VAR_DECL
)
1275 compare_values (DECL_HAS_DEBUG_EXPR_P
);
1276 compare_values (DECL_NONLOCAL_FRAME
);
1278 if (code
== RESULT_DECL
1279 || code
== PARM_DECL
1280 || code
== VAR_DECL
)
1282 compare_values (DECL_BY_REFERENCE
);
1283 if (code
== VAR_DECL
1284 || code
== PARM_DECL
)
1285 compare_values (DECL_HAS_VALUE_EXPR_P
);
1289 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
1290 compare_values (DECL_REGISTER
);
1292 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1294 compare_values (DECL_COMMON
);
1295 compare_values (DECL_DLLIMPORT_P
);
1296 compare_values (DECL_WEAK
);
1297 compare_values (DECL_SEEN_IN_BIND_EXPR_P
);
1298 compare_values (DECL_COMDAT
);
1299 compare_values (DECL_VISIBILITY
);
1300 compare_values (DECL_VISIBILITY_SPECIFIED
);
1301 if (code
== VAR_DECL
)
1303 compare_values (DECL_HARD_REGISTER
);
1304 /* DECL_IN_TEXT_SECTION is set during final asm output only. */
1305 compare_values (DECL_IN_CONSTANT_POOL
);
1306 compare_values (DECL_TLS_MODEL
);
1308 if (VAR_OR_FUNCTION_DECL_P (t1
))
1309 compare_values (DECL_INIT_PRIORITY
);
1312 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1314 compare_values (DECL_BUILT_IN_CLASS
);
1315 compare_values (DECL_STATIC_CONSTRUCTOR
);
1316 compare_values (DECL_STATIC_DESTRUCTOR
);
1317 compare_values (DECL_UNINLINABLE
);
1318 compare_values (DECL_POSSIBLY_INLINED
);
1319 compare_values (DECL_IS_NOVOPS
);
1320 compare_values (DECL_IS_RETURNS_TWICE
);
1321 compare_values (DECL_IS_MALLOC
);
1322 compare_values (DECL_IS_OPERATOR_NEW
);
1323 compare_values (DECL_DECLARED_INLINE_P
);
1324 compare_values (DECL_STATIC_CHAIN
);
1325 compare_values (DECL_NO_INLINE_WARNING_P
);
1326 compare_values (DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT
);
1327 compare_values (DECL_NO_LIMIT_STACK
);
1328 compare_values (DECL_DISREGARD_INLINE_LIMITS
);
1329 compare_values (DECL_PURE_P
);
1330 compare_values (DECL_LOOPING_CONST_OR_PURE_P
);
1331 compare_values (DECL_FINAL_P
);
1332 compare_values (DECL_CXX_CONSTRUCTOR_P
);
1333 compare_values (DECL_CXX_DESTRUCTOR_P
);
1334 if (DECL_BUILT_IN_CLASS (t1
) != NOT_BUILT_IN
)
1335 compare_values (DECL_FUNCTION_CODE
);
1336 if (DECL_STATIC_DESTRUCTOR (t1
))
1337 compare_values (DECL_FINI_PRIORITY
);
1340 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
1342 compare_values (TYPE_MODE
);
1343 compare_values (TYPE_STRING_FLAG
);
1344 compare_values (TYPE_NO_FORCE_BLK
);
1345 compare_values (TYPE_NEEDS_CONSTRUCTING
);
1346 if (RECORD_OR_UNION_TYPE_P (t1
))
1348 compare_values (TYPE_TRANSPARENT_AGGR
);
1349 compare_values (TYPE_FINAL_P
);
1351 else if (code
== ARRAY_TYPE
)
1352 compare_values (TYPE_NONALIASED_COMPONENT
);
1353 compare_values (TYPE_PACKED
);
1354 compare_values (TYPE_RESTRICT
);
1355 compare_values (TYPE_USER_ALIGN
);
1356 compare_values (TYPE_READONLY
);
1357 compare_values (TYPE_PRECISION
);
1358 compare_values (TYPE_ALIGN
);
1359 compare_values (TYPE_ALIAS_SET
);
1362 /* We don't want to compare locations, so there is nothing do compare
1365 /* BLOCKs are function local and we don't merge anything there, so
1366 simply refuse to merge. */
1367 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
1370 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
1371 if (strcmp (TRANSLATION_UNIT_LANGUAGE (t1
),
1372 TRANSLATION_UNIT_LANGUAGE (t2
)) != 0)
1375 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
))
1376 if (memcmp (TREE_TARGET_OPTION (t1
), TREE_TARGET_OPTION (t2
),
1377 sizeof (struct cl_target_option
)) != 0)
1380 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
1381 if (memcmp (TREE_OPTIMIZATION (t1
), TREE_OPTIMIZATION (t2
),
1382 sizeof (struct cl_optimization
)) != 0)
1385 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1386 if (vec_safe_length (BINFO_BASE_ACCESSES (t1
))
1387 != vec_safe_length (BINFO_BASE_ACCESSES (t2
)))
1390 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1391 compare_values (CONSTRUCTOR_NELTS
);
1393 if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
1394 if (IDENTIFIER_LENGTH (t1
) != IDENTIFIER_LENGTH (t2
)
1395 || memcmp (IDENTIFIER_POINTER (t1
), IDENTIFIER_POINTER (t2
),
1396 IDENTIFIER_LENGTH (t1
)) != 0)
1399 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
1400 if (TREE_STRING_LENGTH (t1
) != TREE_STRING_LENGTH (t2
)
1401 || memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
1402 TREE_STRING_LENGTH (t1
)) != 0)
1405 #undef compare_values
1408 /* Compare pointer fields. */
1410 /* Recurse. Search & Replaced from DFS_write_tree_body.
1411 Folding the early checks into the compare_tree_edges recursion
1412 macro makes debugging way quicker as you are able to break on
1413 compare_tree_sccs_1 and simply finish until a call returns false
1414 to spot the SCC members with the difference. */
1415 #define compare_tree_edges(E1, E2) \
1417 tree t1_ = (E1), t2_ = (E2); \
1420 || !TREE_VISITED (t2_) \
1421 || (!TREE_ASM_WRITTEN (t2_) \
1422 && !compare_tree_sccs_1 (t1_, t2_, map)))) \
1424 /* Only non-NULL trees outside of the SCC may compare equal. */ \
1425 gcc_checking_assert (t1_ != t2_ || (!t2_ || !TREE_VISITED (t2_))); \
1428 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
1430 if (code
!= IDENTIFIER_NODE
)
1431 compare_tree_edges (TREE_TYPE (t1
), TREE_TYPE (t2
));
1434 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
1437 /* Note that the number of elements for EXPR has already been emitted
1438 in EXPR's header (see streamer_write_tree_header). */
1439 for (i
= 0; i
< VECTOR_CST_NELTS (t1
); ++i
)
1440 compare_tree_edges (VECTOR_CST_ELT (t1
, i
), VECTOR_CST_ELT (t2
, i
));
1443 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
1445 compare_tree_edges (TREE_REALPART (t1
), TREE_REALPART (t2
));
1446 compare_tree_edges (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
1449 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
1451 compare_tree_edges (DECL_NAME (t1
), DECL_NAME (t2
));
1452 /* ??? Global decls from different TUs have non-matching
1453 TRANSLATION_UNIT_DECLs. Only consider a small set of
1454 decls equivalent, we should not end up merging others. */
1455 if ((code
== TYPE_DECL
1456 || code
== NAMESPACE_DECL
1457 || code
== IMPORTED_DECL
1458 || code
== CONST_DECL
1459 || (VAR_OR_FUNCTION_DECL_P (t1
)
1460 && (TREE_PUBLIC (t1
) || DECL_EXTERNAL (t1
))))
1461 && DECL_FILE_SCOPE_P (t1
) && DECL_FILE_SCOPE_P (t2
))
1464 compare_tree_edges (DECL_CONTEXT (t1
), DECL_CONTEXT (t2
));
1467 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1469 compare_tree_edges (DECL_SIZE (t1
), DECL_SIZE (t2
));
1470 compare_tree_edges (DECL_SIZE_UNIT (t1
), DECL_SIZE_UNIT (t2
));
1471 compare_tree_edges (DECL_ATTRIBUTES (t1
), DECL_ATTRIBUTES (t2
));
1472 if ((code
== VAR_DECL
1473 || code
== PARM_DECL
)
1474 && DECL_HAS_VALUE_EXPR_P (t1
))
1475 compare_tree_edges (DECL_VALUE_EXPR (t1
), DECL_VALUE_EXPR (t2
));
1476 if (code
== VAR_DECL
1477 && DECL_HAS_DEBUG_EXPR_P (t1
))
1478 compare_tree_edges (DECL_DEBUG_EXPR (t1
), DECL_DEBUG_EXPR (t2
));
1479 /* LTO specific edges. */
1480 if (code
!= FUNCTION_DECL
1481 && code
!= TRANSLATION_UNIT_DECL
)
1482 compare_tree_edges (DECL_INITIAL (t1
), DECL_INITIAL (t2
));
1485 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
1487 if (code
== FUNCTION_DECL
)
1490 for (a1
= DECL_ARGUMENTS (t1
), a2
= DECL_ARGUMENTS (t2
);
1492 a1
= TREE_CHAIN (a1
), a2
= TREE_CHAIN (a2
))
1493 compare_tree_edges (a1
, a2
);
1494 compare_tree_edges (DECL_RESULT (t1
), DECL_RESULT (t2
));
1496 else if (code
== TYPE_DECL
)
1497 compare_tree_edges (DECL_ORIGINAL_TYPE (t1
), DECL_ORIGINAL_TYPE (t2
));
1498 compare_tree_edges (DECL_VINDEX (t1
), DECL_VINDEX (t2
));
1501 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1503 /* Make sure we don't inadvertently set the assembler name. */
1504 if (DECL_ASSEMBLER_NAME_SET_P (t1
))
1505 compare_tree_edges (DECL_ASSEMBLER_NAME (t1
),
1506 DECL_ASSEMBLER_NAME (t2
));
1507 compare_tree_edges (DECL_SECTION_NAME (t1
), DECL_SECTION_NAME (t2
));
1508 compare_tree_edges (DECL_COMDAT_GROUP (t1
), DECL_COMDAT_GROUP (t2
));
1511 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
1513 compare_tree_edges (DECL_FIELD_OFFSET (t1
), DECL_FIELD_OFFSET (t2
));
1514 compare_tree_edges (DECL_BIT_FIELD_TYPE (t1
), DECL_BIT_FIELD_TYPE (t2
));
1515 compare_tree_edges (DECL_BIT_FIELD_REPRESENTATIVE (t1
),
1516 DECL_BIT_FIELD_REPRESENTATIVE (t2
));
1517 compare_tree_edges (DECL_FIELD_BIT_OFFSET (t1
),
1518 DECL_FIELD_BIT_OFFSET (t2
));
1519 compare_tree_edges (DECL_FCONTEXT (t1
), DECL_FCONTEXT (t2
));
1522 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1524 compare_tree_edges (DECL_FUNCTION_PERSONALITY (t1
),
1525 DECL_FUNCTION_PERSONALITY (t2
));
1526 compare_tree_edges (DECL_FUNCTION_SPECIFIC_TARGET (t1
),
1527 DECL_FUNCTION_SPECIFIC_TARGET (t2
));
1528 compare_tree_edges (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t1
),
1529 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t2
));
1532 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
1534 compare_tree_edges (TYPE_SIZE (t1
), TYPE_SIZE (t2
));
1535 compare_tree_edges (TYPE_SIZE_UNIT (t1
), TYPE_SIZE_UNIT (t2
));
1536 compare_tree_edges (TYPE_ATTRIBUTES (t1
), TYPE_ATTRIBUTES (t2
));
1537 compare_tree_edges (TYPE_NAME (t1
), TYPE_NAME (t2
));
1538 /* Do not compare TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
1539 reconstructed during fixup. */
1540 /* Do not compare TYPE_NEXT_VARIANT, we reconstruct the variant lists
1542 compare_tree_edges (TYPE_MAIN_VARIANT (t1
), TYPE_MAIN_VARIANT (t2
));
1543 /* ??? Global types from different TUs have non-matching
1544 TRANSLATION_UNIT_DECLs. Still merge them if they are otherwise
1546 if (TYPE_FILE_SCOPE_P (t1
) && TYPE_FILE_SCOPE_P (t2
))
1549 compare_tree_edges (TYPE_CONTEXT (t1
), TYPE_CONTEXT (t2
));
1550 /* TYPE_CANONICAL is re-computed during type merging, so do not
1552 compare_tree_edges (TYPE_STUB_DECL (t1
), TYPE_STUB_DECL (t2
));
1555 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
1557 if (code
== ENUMERAL_TYPE
)
1558 compare_tree_edges (TYPE_VALUES (t1
), TYPE_VALUES (t2
));
1559 else if (code
== ARRAY_TYPE
)
1560 compare_tree_edges (TYPE_DOMAIN (t1
), TYPE_DOMAIN (t2
));
1561 else if (RECORD_OR_UNION_TYPE_P (t1
))
1564 for (f1
= TYPE_FIELDS (t1
), f2
= TYPE_FIELDS (t2
);
1566 f1
= TREE_CHAIN (f1
), f2
= TREE_CHAIN (f2
))
1567 compare_tree_edges (f1
, f2
);
1568 compare_tree_edges (TYPE_BINFO (t1
), TYPE_BINFO (t2
));
1570 else if (code
== FUNCTION_TYPE
1571 || code
== METHOD_TYPE
)
1572 compare_tree_edges (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
));
1573 if (!POINTER_TYPE_P (t1
))
1574 compare_tree_edges (TYPE_MINVAL (t1
), TYPE_MINVAL (t2
));
1575 compare_tree_edges (TYPE_MAXVAL (t1
), TYPE_MAXVAL (t2
));
1578 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
1580 compare_tree_edges (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
));
1581 compare_tree_edges (TREE_VALUE (t1
), TREE_VALUE (t2
));
1582 compare_tree_edges (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
1585 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1586 for (int i
= 0; i
< TREE_VEC_LENGTH (t1
); i
++)
1587 compare_tree_edges (TREE_VEC_ELT (t1
, i
), TREE_VEC_ELT (t2
, i
));
1589 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
1591 for (int i
= 0; i
< TREE_OPERAND_LENGTH (t1
); i
++)
1592 compare_tree_edges (TREE_OPERAND (t1
, i
),
1593 TREE_OPERAND (t2
, i
));
1595 /* BLOCKs are function local and we don't merge anything there. */
1596 if (TREE_BLOCK (t1
) || TREE_BLOCK (t2
))
1600 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1604 /* Lengths have already been compared above. */
1605 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (t1
), i
, t
)
1606 compare_tree_edges (t
, BINFO_BASE_BINFO (t2
, i
));
1607 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (t1
), i
, t
)
1608 compare_tree_edges (t
, BINFO_BASE_ACCESS (t2
, i
));
1609 compare_tree_edges (BINFO_OFFSET (t1
), BINFO_OFFSET (t2
));
1610 compare_tree_edges (BINFO_VTABLE (t1
), BINFO_VTABLE (t2
));
1611 compare_tree_edges (BINFO_VPTR_FIELD (t1
), BINFO_VPTR_FIELD (t2
));
1612 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
1613 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
1616 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1620 /* Lengths have already been compared above. */
1621 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, index
, value
)
1623 compare_tree_edges (index
, CONSTRUCTOR_ELT (t2
, i
)->index
);
1624 compare_tree_edges (value
, CONSTRUCTOR_ELT (t2
, i
)->value
);
1628 #undef compare_tree_edges
1633 /* Compare the tree scc SCC to the prevailing candidate PSCC, filling
1634 out MAP if they are equal. */
1637 compare_tree_sccs (tree_scc
*pscc
, tree_scc
*scc
,
1640 /* Assume SCC entry hashes are sorted after their cardinality. Which
1641 means we can simply take the first n-tuple of equal hashes
1642 (which is recorded as entry_len) and do n SCC entry candidate
1644 for (unsigned i
= 0; i
< pscc
->entry_len
; ++i
)
1647 num_scc_compare_collisions
++;
1648 if (compare_tree_sccs_1 (pscc
->entries
[0], scc
->entries
[i
], &mapp
))
1650 /* Equal - no need to reset TREE_VISITED or TREE_ASM_WRITTEN
1651 on the scc as all trees will be freed. */
1654 /* Reset TREE_ASM_WRITTEN on scc for the next compare or in case
1655 the SCC prevails. */
1656 for (unsigned j
= 0; j
< scc
->len
; ++j
)
1657 TREE_ASM_WRITTEN (scc
->entries
[j
]) = 0;
1663 /* QSort sort function to sort a map of two pointers after the 2nd
1667 cmp_tree (const void *p1_
, const void *p2_
)
1669 tree
*p1
= (tree
*)(const_cast<void *>(p1_
));
1670 tree
*p2
= (tree
*)(const_cast<void *>(p2_
));
1673 return ((uintptr_t)p1
[1] < (uintptr_t)p2
[1]) ? -1 : 1;
1676 /* Try to unify the SCC with nodes FROM to FROM + LEN in CACHE and
1677 hash value SCC_HASH with an already recorded SCC. Return true if
1678 that was successful, otherwise return false. */
1681 unify_scc (struct streamer_tree_cache_d
*cache
, unsigned from
,
1682 unsigned len
, unsigned scc_entry_len
, hashval_t scc_hash
)
1684 bool unified_p
= false;
1686 = (tree_scc
*) alloca (sizeof (tree_scc
) + (len
- 1) * sizeof (tree
));
1688 scc
->hash
= scc_hash
;
1690 scc
->entry_len
= scc_entry_len
;
1691 for (unsigned i
= 0; i
< len
; ++i
)
1693 tree t
= streamer_tree_cache_get_tree (cache
, from
+ i
);
1694 scc
->entries
[i
] = t
;
1695 /* Do not merge SCCs with local entities inside them. Also do
1696 not merge TRANSLATION_UNIT_DECLs. */
1697 if (TREE_CODE (t
) == TRANSLATION_UNIT_DECL
1698 || (VAR_OR_FUNCTION_DECL_P (t
)
1699 && !(TREE_PUBLIC (t
) || DECL_EXTERNAL (t
)))
1700 || TREE_CODE (t
) == LABEL_DECL
)
1702 /* Avoid doing any work for these cases and do not worry to
1703 record the SCCs for further merging. */
1708 /* Look for the list of candidate SCCs to compare against. */
1710 slot
= tree_scc_hash
.find_slot_with_hash (scc
, scc_hash
, INSERT
);
1713 /* Try unifying against each candidate. */
1716 /* Set TREE_VISITED on the scc so we can easily identify tree nodes
1717 outside of the scc when following tree edges. Make sure
1718 that TREE_ASM_WRITTEN is unset so we can use it as 2nd bit
1719 to track whether we visited the SCC member during the compare.
1720 We cannot use TREE_VISITED on the pscc members as the extended
1721 scc and pscc can overlap. */
1722 for (unsigned i
= 0; i
< scc
->len
; ++i
)
1724 TREE_VISITED (scc
->entries
[i
]) = 1;
1725 gcc_checking_assert (!TREE_ASM_WRITTEN (scc
->entries
[i
]));
1728 tree
*map
= XALLOCAVEC (tree
, 2 * len
);
1729 for (tree_scc
*pscc
= *slot
; pscc
; pscc
= pscc
->next
)
1731 if (!compare_tree_sccs (pscc
, scc
, map
))
1734 /* Found an equal SCC. */
1736 num_scc_compare_collisions
--;
1738 total_scc_size_merged
+= len
;
1740 #ifdef ENABLE_CHECKING
1741 for (unsigned i
= 0; i
< len
; ++i
)
1743 tree t
= map
[2*i
+1];
1744 enum tree_code code
= TREE_CODE (t
);
1745 /* IDENTIFIER_NODEs should be singletons and are merged by the
1746 streamer. The others should be singletons, too, and we
1747 should not merge them in any way. */
1748 gcc_assert (code
!= TRANSLATION_UNIT_DECL
1749 && code
!= IDENTIFIER_NODE
1750 && !streamer_handle_as_builtin_p (t
));
1754 /* Fixup the streamer cache with the prevailing nodes according
1755 to the tree node mapping computed by compare_tree_sccs. */
1757 streamer_tree_cache_replace_tree (cache
, pscc
->entries
[0], from
);
1760 tree
*map2
= XALLOCAVEC (tree
, 2 * len
);
1761 for (unsigned i
= 0; i
< len
; ++i
)
1763 map2
[i
*2] = (tree
)(uintptr_t)(from
+ i
);
1764 map2
[i
*2+1] = scc
->entries
[i
];
1766 qsort (map2
, len
, 2 * sizeof (tree
), cmp_tree
);
1767 qsort (map
, len
, 2 * sizeof (tree
), cmp_tree
);
1768 for (unsigned i
= 0; i
< len
; ++i
)
1769 streamer_tree_cache_replace_tree (cache
, map
[2*i
],
1770 (uintptr_t)map2
[2*i
]);
1773 /* Free the tree nodes from the read SCC. */
1774 for (unsigned i
= 0; i
< len
; ++i
)
1776 if (TYPE_P (scc
->entries
[i
]))
1778 ggc_free (scc
->entries
[i
]);
1784 /* Reset TREE_VISITED if we didn't unify the SCC with another. */
1786 for (unsigned i
= 0; i
< scc
->len
; ++i
)
1787 TREE_VISITED (scc
->entries
[i
]) = 0;
1790 /* If we didn't unify it to any candidate duplicate the relevant
1791 pieces to permanent storage and link it into the chain. */
1795 = XOBNEWVAR (&tree_scc_hash_obstack
, tree_scc
, sizeof (tree_scc
));
1796 memcpy (pscc
, scc
, sizeof (tree_scc
));
1797 pscc
->next
= (*slot
);
1804 /* Read all the symbols from buffer DATA, using descriptors in DECL_DATA.
1805 RESOLUTIONS is the set of symbols picked by the linker (read from the
1806 resolution file when the linker plugin is being used). */
1809 lto_read_decls (struct lto_file_decl_data
*decl_data
, const void *data
,
1810 vec
<ld_plugin_symbol_resolution_t
> resolutions
)
1812 const struct lto_decl_header
*header
= (const struct lto_decl_header
*) data
;
1813 const int decl_offset
= sizeof (struct lto_decl_header
);
1814 const int main_offset
= decl_offset
+ header
->decl_state_size
;
1815 const int string_offset
= main_offset
+ header
->main_size
;
1816 struct lto_input_block ib_main
;
1817 struct data_in
*data_in
;
1819 const uint32_t *data_ptr
, *data_end
;
1820 uint32_t num_decl_states
;
1822 LTO_INIT_INPUT_BLOCK (ib_main
, (const char *) data
+ main_offset
, 0,
1825 data_in
= lto_data_in_create (decl_data
, (const char *) data
+ string_offset
,
1826 header
->string_size
, resolutions
);
1828 /* We do not uniquify the pre-loaded cache entries, those are middle-end
1829 internal types that should not be merged. */
1831 /* Read the global declarations and types. */
1832 while (ib_main
.p
< ib_main
.len
)
1835 unsigned from
= data_in
->reader_cache
->nodes
.length ();
1836 /* Read and uniquify SCCs as in the input stream. */
1837 enum LTO_tags tag
= streamer_read_record_start (&ib_main
);
1838 if (tag
== LTO_tree_scc
)
1841 unsigned scc_entry_len
;
1842 hashval_t scc_hash
= lto_input_scc (&ib_main
, data_in
, &len_
,
1844 unsigned len
= data_in
->reader_cache
->nodes
.length () - from
;
1845 gcc_assert (len
== len_
);
1847 total_scc_size
+= len
;
1850 /* We have the special case of size-1 SCCs that are pre-merged
1851 by means of identifier and string sharing for example.
1852 ??? Maybe we should avoid streaming those as SCCs. */
1853 tree first
= streamer_tree_cache_get_tree (data_in
->reader_cache
,
1856 && (TREE_CODE (first
) == IDENTIFIER_NODE
1857 || TREE_CODE (first
) == INTEGER_CST
1858 || TREE_CODE (first
) == TRANSLATION_UNIT_DECL
1859 || streamer_handle_as_builtin_p (first
)))
1862 /* Try to unify the SCC with already existing ones. */
1864 && unify_scc (data_in
->reader_cache
, from
,
1865 len
, scc_entry_len
, scc_hash
))
1868 /* Do remaining fixup tasks for prevailing nodes. */
1869 bool seen_type
= false;
1870 for (unsigned i
= 0; i
< len
; ++i
)
1872 tree t
= streamer_tree_cache_get_tree (data_in
->reader_cache
,
1874 /* Reconstruct the type variant and pointer-to/reference-to
1879 num_prevailing_types
++;
1880 lto_fixup_prevailing_type (t
);
1882 /* Compute the canonical type of all types.
1883 ??? Should be able to assert that !TYPE_CANONICAL. */
1884 if (TYPE_P (t
) && !TYPE_CANONICAL (t
))
1885 gimple_register_canonical_type (t
);
1886 /* Link shared INTEGER_CSTs into TYPE_CACHED_VALUEs of its
1887 type which is also member of this SCC. */
1888 if (TREE_CODE (t
) == INTEGER_CST
1889 && !TREE_OVERFLOW (t
))
1890 cache_integer_cst (t
);
1891 /* Register TYPE_DECLs with the debuginfo machinery. */
1893 && TREE_CODE (t
) == TYPE_DECL
)
1894 debug_hooks
->type_decl (t
, !DECL_FILE_SCOPE_P (t
));
1897 /* Register variables and functions with the
1899 if (TREE_CODE (t
) == VAR_DECL
)
1900 lto_register_var_decl_in_symtab (data_in
, t
, from
+ i
);
1901 else if (TREE_CODE (t
) == FUNCTION_DECL
1902 && !DECL_BUILT_IN (t
))
1903 lto_register_function_decl_in_symtab (data_in
, t
, from
+ i
);
1904 /* Scan the tree for references to global functions or
1905 variables and record those for later fixup. */
1906 if (mentions_vars_p (t
))
1907 vec_safe_push (tree_with_vars
, t
);
1911 num_type_scc_trees
+= len
;
1915 /* Pickle stray references. */
1916 t
= lto_input_tree_1 (&ib_main
, data_in
, tag
, 0);
1917 gcc_assert (t
&& data_in
->reader_cache
->nodes
.length () == from
);
1921 /* Read in lto_in_decl_state objects. */
1922 data_ptr
= (const uint32_t *) ((const char*) data
+ decl_offset
);
1924 (const uint32_t *) ((const char*) data_ptr
+ header
->decl_state_size
);
1925 num_decl_states
= *data_ptr
++;
1927 gcc_assert (num_decl_states
> 0);
1928 decl_data
->global_decl_state
= lto_new_in_decl_state ();
1929 data_ptr
= lto_read_in_decl_state (data_in
, data_ptr
,
1930 decl_data
->global_decl_state
);
1932 /* Read in per-function decl states and enter them in hash table. */
1933 decl_data
->function_decl_states
=
1934 htab_create_ggc (37, lto_hash_in_decl_state
, lto_eq_in_decl_state
, NULL
);
1936 for (i
= 1; i
< num_decl_states
; i
++)
1938 struct lto_in_decl_state
*state
= lto_new_in_decl_state ();
1941 data_ptr
= lto_read_in_decl_state (data_in
, data_ptr
, state
);
1942 slot
= htab_find_slot (decl_data
->function_decl_states
, state
, INSERT
);
1943 gcc_assert (*slot
== NULL
);
1947 if (data_ptr
!= data_end
)
1948 internal_error ("bytecode stream: garbage at the end of symbols section");
1950 /* Set the current decl state to be the global state. */
1951 decl_data
->current_decl_state
= decl_data
->global_decl_state
;
1953 lto_data_in_delete (data_in
);
1956 /* Custom version of strtoll, which is not portable. */
1958 static HOST_WIDEST_INT
1959 lto_parse_hex (const char *p
)
1961 HOST_WIDEST_INT ret
= 0;
1963 for (; *p
!= '\0'; ++p
)
1968 if (c
>= '0' && c
<= '9')
1970 else if (c
>= 'a' && c
<= 'f')
1971 part
= c
- 'a' + 10;
1972 else if (c
>= 'A' && c
<= 'F')
1973 part
= c
- 'A' + 10;
1975 internal_error ("could not parse hex number");
1982 /* Read resolution for file named FILE_NAME. The resolution is read from
1986 lto_resolution_read (splay_tree file_ids
, FILE *resolution
, lto_file
*file
)
1988 /* We require that objects in the resolution file are in the same
1989 order as the lto1 command line. */
1990 unsigned int name_len
;
1992 unsigned int num_symbols
;
1994 struct lto_file_decl_data
*file_data
;
1995 splay_tree_node nd
= NULL
;
2000 name_len
= strlen (file
->filename
);
2001 obj_name
= XNEWVEC (char, name_len
+ 1);
2002 fscanf (resolution
, " "); /* Read white space. */
2004 fread (obj_name
, sizeof (char), name_len
, resolution
);
2005 obj_name
[name_len
] = '\0';
2006 if (filename_cmp (obj_name
, file
->filename
) != 0)
2007 internal_error ("unexpected file name %s in linker resolution file. "
2008 "Expected %s", obj_name
, file
->filename
);
2009 if (file
->offset
!= 0)
2013 HOST_WIDEST_INT offset
;
2014 t
= fscanf (resolution
, "@0x%16s", offset_p
);
2016 internal_error ("could not parse file offset");
2017 offset
= lto_parse_hex (offset_p
);
2018 if (offset
!= file
->offset
)
2019 internal_error ("unexpected offset");
2024 fscanf (resolution
, "%u", &num_symbols
);
2026 for (i
= 0; i
< num_symbols
; i
++)
2030 unsigned HOST_WIDE_INT id
;
2032 enum ld_plugin_symbol_resolution r
= (enum ld_plugin_symbol_resolution
) 0;
2034 unsigned int lto_resolution_str_len
=
2035 sizeof (lto_resolution_str
) / sizeof (char *);
2038 t
= fscanf (resolution
, "%u " HOST_WIDE_INT_PRINT_HEX_PURE
" %26s %*[^\n]\n",
2039 &index
, &id
, r_str
);
2041 internal_error ("invalid line in the resolution file");
2043 for (j
= 0; j
< lto_resolution_str_len
; j
++)
2045 if (strcmp (lto_resolution_str
[j
], r_str
) == 0)
2047 r
= (enum ld_plugin_symbol_resolution
) j
;
2051 if (j
== lto_resolution_str_len
)
2052 internal_error ("invalid resolution in the resolution file");
2054 if (!(nd
&& lto_splay_tree_id_equal_p (nd
->key
, id
)))
2056 nd
= lto_splay_tree_lookup (file_ids
, id
);
2058 internal_error ("resolution sub id %wx not in object file", id
);
2061 file_data
= (struct lto_file_decl_data
*)nd
->value
;
2062 /* The indexes are very sparse. To save memory save them in a compact
2063 format that is only unpacked later when the subfile is processed. */
2066 file_data
->respairs
.safe_push (rp
);
2067 if (file_data
->max_index
< index
)
2068 file_data
->max_index
= index
;
2072 /* List of file_decl_datas */
2073 struct file_data_list
2075 struct lto_file_decl_data
*first
, *last
;
2078 /* Is the name for a id'ed LTO section? */
2081 lto_section_with_id (const char *name
, unsigned HOST_WIDE_INT
*id
)
2085 if (strncmp (name
, LTO_SECTION_NAME_PREFIX
, strlen (LTO_SECTION_NAME_PREFIX
)))
2087 s
= strrchr (name
, '.');
2088 return s
&& sscanf (s
, "." HOST_WIDE_INT_PRINT_HEX_PURE
, id
) == 1;
2091 /* Create file_data of each sub file id */
2094 create_subid_section_table (struct lto_section_slot
*ls
, splay_tree file_ids
,
2095 struct file_data_list
*list
)
2097 struct lto_section_slot s_slot
, *new_slot
;
2098 unsigned HOST_WIDE_INT id
;
2102 struct lto_file_decl_data
*file_data
;
2104 if (!lto_section_with_id (ls
->name
, &id
))
2107 /* Find hash table of sub module id */
2108 nd
= lto_splay_tree_lookup (file_ids
, id
);
2111 file_data
= (struct lto_file_decl_data
*)nd
->value
;
2115 file_data
= ggc_alloc_lto_file_decl_data ();
2116 memset(file_data
, 0, sizeof (struct lto_file_decl_data
));
2118 file_data
->section_hash_table
= lto_obj_create_section_hash_table ();;
2119 lto_splay_tree_insert (file_ids
, id
, file_data
);
2121 /* Maintain list in linker order */
2123 list
->first
= file_data
;
2125 list
->last
->next
= file_data
;
2126 list
->last
= file_data
;
2129 /* Copy section into sub module hash table */
2130 new_name
= XDUPVEC (char, ls
->name
, strlen (ls
->name
) + 1);
2131 s_slot
.name
= new_name
;
2132 hash_slot
= htab_find_slot (file_data
->section_hash_table
, &s_slot
, INSERT
);
2133 gcc_assert (*hash_slot
== NULL
);
2135 new_slot
= XDUP (struct lto_section_slot
, ls
);
2136 new_slot
->name
= new_name
;
2137 *hash_slot
= new_slot
;
2141 /* Read declarations and other initializations for a FILE_DATA. */
2144 lto_file_finalize (struct lto_file_decl_data
*file_data
, lto_file
*file
)
2148 vec
<ld_plugin_symbol_resolution_t
>
2149 resolutions
= vNULL
;
2153 /* Create vector for fast access of resolution. We do this lazily
2155 resolutions
.safe_grow_cleared (file_data
->max_index
+ 1);
2156 for (i
= 0; file_data
->respairs
.iterate (i
, &rp
); i
++)
2157 resolutions
[rp
->index
] = rp
->res
;
2158 file_data
->respairs
.release ();
2160 file_data
->renaming_hash_table
= lto_create_renaming_table ();
2161 file_data
->file_name
= file
->filename
;
2162 data
= lto_get_section_data (file_data
, LTO_section_decls
, NULL
, &len
);
2165 internal_error ("cannot read LTO decls from %s", file_data
->file_name
);
2168 /* Frees resolutions */
2169 lto_read_decls (file_data
, data
, resolutions
);
2170 lto_free_section_data (file_data
, LTO_section_decls
, NULL
, data
, len
);
2173 /* Finalize FILE_DATA in FILE and increase COUNT. */
2176 lto_create_files_from_ids (lto_file
*file
, struct lto_file_decl_data
*file_data
,
2179 lto_file_finalize (file_data
, file
);
2180 if (cgraph_dump_file
)
2181 fprintf (cgraph_dump_file
, "Creating file %s with sub id " HOST_WIDE_INT_PRINT_HEX
"\n",
2182 file_data
->file_name
, file_data
->id
);
2187 /* Generate a TREE representation for all types and external decls
2190 Read all of the globals out of the file. Then read the cgraph
2191 and process the .o index into the cgraph nodes so that it can open
2192 the .o file to load the functions and ipa information. */
2194 static struct lto_file_decl_data
*
2195 lto_file_read (lto_file
*file
, FILE *resolution_file
, int *count
)
2197 struct lto_file_decl_data
*file_data
= NULL
;
2198 splay_tree file_ids
;
2199 htab_t section_hash_table
;
2200 struct lto_section_slot
*section
;
2201 struct file_data_list file_list
;
2202 struct lto_section_list section_list
;
2204 memset (§ion_list
, 0, sizeof (struct lto_section_list
));
2205 section_hash_table
= lto_obj_build_section_table (file
, §ion_list
);
2207 /* Find all sub modules in the object and put their sections into new hash
2208 tables in a splay tree. */
2209 file_ids
= lto_splay_tree_new ();
2210 memset (&file_list
, 0, sizeof (struct file_data_list
));
2211 for (section
= section_list
.first
; section
!= NULL
; section
= section
->next
)
2212 create_subid_section_table (section
, file_ids
, &file_list
);
2214 /* Add resolutions to file ids */
2215 lto_resolution_read (file_ids
, resolution_file
, file
);
2217 /* Finalize each lto file for each submodule in the merged object */
2218 for (file_data
= file_list
.first
; file_data
!= NULL
; file_data
= file_data
->next
)
2219 lto_create_files_from_ids (file
, file_data
, count
);
2221 splay_tree_delete (file_ids
);
2222 htab_delete (section_hash_table
);
2224 return file_list
.first
;
2227 #if HAVE_MMAP_FILE && HAVE_SYSCONF && defined _SC_PAGE_SIZE
2228 #define LTO_MMAP_IO 1
2232 /* Page size of machine is used for mmap and munmap calls. */
2233 static size_t page_mask
;
2236 /* Get the section data of length LEN from FILENAME starting at
2237 OFFSET. The data segment must be freed by the caller when the
2238 caller is finished. Returns NULL if all was not well. */
2241 lto_read_section_data (struct lto_file_decl_data
*file_data
,
2242 intptr_t offset
, size_t len
)
2246 static char *fd_name
;
2248 intptr_t computed_len
;
2249 intptr_t computed_offset
;
2253 /* Keep a single-entry file-descriptor cache. The last file we
2254 touched will get closed at exit.
2255 ??? Eventually we want to add a more sophisticated larger cache
2256 or rather fix function body streaming to not stream them in
2257 practically random order. */
2259 && filename_cmp (fd_name
, file_data
->file_name
) != 0)
2267 fd
= open (file_data
->file_name
, O_RDONLY
|O_BINARY
);
2270 fatal_error ("Cannot open %s", file_data
->file_name
);
2273 fd_name
= xstrdup (file_data
->file_name
);
2279 size_t page_size
= sysconf (_SC_PAGE_SIZE
);
2280 page_mask
= ~(page_size
- 1);
2283 computed_offset
= offset
& page_mask
;
2284 diff
= offset
- computed_offset
;
2285 computed_len
= len
+ diff
;
2287 result
= (char *) mmap (NULL
, computed_len
, PROT_READ
, MAP_PRIVATE
,
2288 fd
, computed_offset
);
2289 if (result
== MAP_FAILED
)
2291 fatal_error ("Cannot map %s", file_data
->file_name
);
2295 return result
+ diff
;
2297 result
= (char *) xmalloc (len
);
2298 if (lseek (fd
, offset
, SEEK_SET
) != offset
2299 || read (fd
, result
, len
) != (ssize_t
) len
)
2302 fatal_error ("Cannot read %s", file_data
->file_name
);
2306 /* Native windows doesn't supports delayed unlink on opened file. So
2307 we close file here again. This produces higher I/O load, but at least
2308 it prevents to have dangling file handles preventing unlink. */
2319 /* Get the section data from FILE_DATA of SECTION_TYPE with NAME.
2320 NAME will be NULL unless the section type is for a function
2324 get_section_data (struct lto_file_decl_data
*file_data
,
2325 enum lto_section_type section_type
,
2329 htab_t section_hash_table
= file_data
->section_hash_table
;
2330 struct lto_section_slot
*f_slot
;
2331 struct lto_section_slot s_slot
;
2332 const char *section_name
= lto_get_section_name (section_type
, name
, file_data
);
2336 s_slot
.name
= section_name
;
2337 f_slot
= (struct lto_section_slot
*) htab_find (section_hash_table
, &s_slot
);
2340 data
= lto_read_section_data (file_data
, f_slot
->start
, f_slot
->len
);
2344 free (CONST_CAST (char *, section_name
));
2349 /* Free the section data from FILE_DATA of SECTION_TYPE with NAME that
2350 starts at OFFSET and has LEN bytes. */
2353 free_section_data (struct lto_file_decl_data
*file_data ATTRIBUTE_UNUSED
,
2354 enum lto_section_type section_type ATTRIBUTE_UNUSED
,
2355 const char *name ATTRIBUTE_UNUSED
,
2356 const char *offset
, size_t len ATTRIBUTE_UNUSED
)
2359 intptr_t computed_len
;
2360 intptr_t computed_offset
;
2365 computed_offset
= ((intptr_t) offset
) & page_mask
;
2366 diff
= (intptr_t) offset
- computed_offset
;
2367 computed_len
= len
+ diff
;
2369 munmap ((caddr_t
) computed_offset
, computed_len
);
2371 free (CONST_CAST(char *, offset
));
2375 static lto_file
*current_lto_file
;
2377 /* Helper for qsort; compare partitions and return one with smaller size.
2378 We sort from greatest to smallest so parallel build doesn't stale on the
2379 longest compilation being executed too late. */
2382 cmp_partitions_size (const void *a
, const void *b
)
2384 const struct ltrans_partition_def
*pa
2385 = *(struct ltrans_partition_def
*const *)a
;
2386 const struct ltrans_partition_def
*pb
2387 = *(struct ltrans_partition_def
*const *)b
;
2388 return pb
->insns
- pa
->insns
;
2391 /* Helper for qsort; compare partitions and return one with smaller order. */
2394 cmp_partitions_order (const void *a
, const void *b
)
2396 const struct ltrans_partition_def
*pa
2397 = *(struct ltrans_partition_def
*const *)a
;
2398 const struct ltrans_partition_def
*pb
2399 = *(struct ltrans_partition_def
*const *)b
;
2400 int ordera
= -1, orderb
= -1;
2402 if (lto_symtab_encoder_size (pa
->encoder
))
2403 ordera
= lto_symtab_encoder_deref (pa
->encoder
, 0)->order
;
2404 if (lto_symtab_encoder_size (pb
->encoder
))
2405 orderb
= lto_symtab_encoder_deref (pb
->encoder
, 0)->order
;
2406 return orderb
- ordera
;
2409 /* Write all output files in WPA mode and the file with the list of
2413 lto_wpa_write_files (void)
2417 ltrans_partition part
;
2418 FILE *ltrans_output_list_stream
;
2419 char *temp_filename
;
2422 /* Open the LTRANS output list. */
2423 if (!ltrans_output_list
)
2424 fatal_error ("no LTRANS output list filename provided");
2425 ltrans_output_list_stream
= fopen (ltrans_output_list
, "w");
2426 if (ltrans_output_list_stream
== NULL
)
2427 fatal_error ("opening LTRANS output list %s: %m", ltrans_output_list
);
2429 timevar_push (TV_WHOPR_WPA
);
2431 FOR_EACH_VEC_ELT (ltrans_partitions
, i
, part
)
2432 lto_stats
.num_output_symtab_nodes
+= lto_symtab_encoder_size (part
->encoder
);
2434 /* Find out statics that need to be promoted
2435 to globals with hidden visibility because they are accessed from multiple
2437 lto_promote_cross_file_statics ();
2439 timevar_pop (TV_WHOPR_WPA
);
2441 timevar_push (TV_WHOPR_WPA_IO
);
2443 /* Generate a prefix for the LTRANS unit files. */
2444 blen
= strlen (ltrans_output_list
);
2445 temp_filename
= (char *) xmalloc (blen
+ sizeof ("2147483648.o"));
2446 strcpy (temp_filename
, ltrans_output_list
);
2447 if (blen
> sizeof (".out")
2448 && strcmp (temp_filename
+ blen
- sizeof (".out") + 1,
2450 temp_filename
[blen
- sizeof (".out") + 1] = '\0';
2451 blen
= strlen (temp_filename
);
2453 n_sets
= ltrans_partitions
.length ();
2455 /* Sort partitions by size so small ones are compiled last.
2456 FIXME: Even when not reordering we may want to output one list for parallel make
2457 and other for final link command. */
2458 ltrans_partitions
.qsort (flag_toplevel_reorder
2459 ? cmp_partitions_size
2460 : cmp_partitions_order
);
2461 for (i
= 0; i
< n_sets
; i
++)
2464 ltrans_partition part
= ltrans_partitions
[i
];
2466 /* Write all the nodes in SET. */
2467 sprintf (temp_filename
+ blen
, "%u.o", i
);
2468 file
= lto_obj_file_open (temp_filename
, true);
2470 fatal_error ("lto_obj_file_open() failed");
2473 fprintf (stderr
, " %s (%s %i insns)", temp_filename
, part
->name
, part
->insns
);
2474 if (cgraph_dump_file
)
2476 lto_symtab_encoder_iterator lsei
;
2478 fprintf (cgraph_dump_file
, "Writing partition %s to file %s, %i insns\n",
2479 part
->name
, temp_filename
, part
->insns
);
2480 fprintf (cgraph_dump_file
, " Symbols in partition: ");
2481 for (lsei
= lsei_start_in_partition (part
->encoder
); !lsei_end_p (lsei
);
2482 lsei_next_in_partition (&lsei
))
2484 symtab_node
*node
= lsei_node (lsei
);
2485 fprintf (cgraph_dump_file
, "%s ", node
->asm_name ());
2487 fprintf (cgraph_dump_file
, "\n Symbols in boundary: ");
2488 for (lsei
= lsei_start (part
->encoder
); !lsei_end_p (lsei
);
2491 symtab_node
*node
= lsei_node (lsei
);
2492 if (!lto_symtab_encoder_in_partition_p (part
->encoder
, node
))
2494 fprintf (cgraph_dump_file
, "%s ", node
->asm_name ());
2495 cgraph_node
*cnode
= dyn_cast
<cgraph_node
> (node
);
2497 && lto_symtab_encoder_encode_body_p (part
->encoder
, cnode
))
2498 fprintf (cgraph_dump_file
, "(body included)");
2501 varpool_node
*vnode
= dyn_cast
<varpool_node
> (node
);
2503 && lto_symtab_encoder_encode_initializer_p (part
->encoder
, vnode
))
2504 fprintf (cgraph_dump_file
, "(initializer included)");
2508 fprintf (cgraph_dump_file
, "\n");
2510 gcc_checking_assert (lto_symtab_encoder_size (part
->encoder
) || !i
);
2512 lto_set_current_out_file (file
);
2514 ipa_write_optimization_summaries (part
->encoder
);
2516 lto_set_current_out_file (NULL
);
2517 lto_obj_file_close (file
);
2519 part
->encoder
= NULL
;
2521 len
= strlen (temp_filename
);
2522 if (fwrite (temp_filename
, 1, len
, ltrans_output_list_stream
) < len
2523 || fwrite ("\n", 1, 1, ltrans_output_list_stream
) < 1)
2524 fatal_error ("writing to LTRANS output list %s: %m",
2525 ltrans_output_list
);
2528 lto_stats
.num_output_files
+= n_sets
;
2530 /* Close the LTRANS output list. */
2531 if (fclose (ltrans_output_list_stream
))
2532 fatal_error ("closing LTRANS output list %s: %m", ltrans_output_list
);
2534 free_ltrans_partitions();
2535 free (temp_filename
);
2537 timevar_pop (TV_WHOPR_WPA_IO
);
2541 /* If TT is a variable or function decl replace it with its
2542 prevailing variant. */
2543 #define LTO_SET_PREVAIL(tt) \
2545 if ((tt) && VAR_OR_FUNCTION_DECL_P (tt) \
2546 && (TREE_PUBLIC (tt) || DECL_EXTERNAL (tt))) \
2548 tt = lto_symtab_prevailing_decl (tt); \
2553 /* Ensure that TT isn't a replacable var of function decl. */
2554 #define LTO_NO_PREVAIL(tt) \
2555 gcc_assert (!(tt) || !VAR_OR_FUNCTION_DECL_P (tt))
2557 /* Given a tree T replace all fields referring to variables or functions
2558 with their prevailing variant. */
2560 lto_fixup_prevailing_decls (tree t
)
2562 enum tree_code code
= TREE_CODE (t
);
2565 gcc_checking_assert (code
!= CONSTRUCTOR
&& code
!= TREE_BINFO
);
2566 LTO_NO_PREVAIL (TREE_TYPE (t
));
2567 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
2568 LTO_NO_PREVAIL (TREE_CHAIN (t
));
2571 LTO_NO_PREVAIL (DECL_NAME (t
));
2572 LTO_SET_PREVAIL (DECL_CONTEXT (t
));
2573 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
2575 LTO_SET_PREVAIL (DECL_SIZE (t
));
2576 LTO_SET_PREVAIL (DECL_SIZE_UNIT (t
));
2577 LTO_SET_PREVAIL (DECL_INITIAL (t
));
2578 LTO_NO_PREVAIL (DECL_ATTRIBUTES (t
));
2579 LTO_SET_PREVAIL (DECL_ABSTRACT_ORIGIN (t
));
2581 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
2583 LTO_NO_PREVAIL (t
->decl_with_vis
.assembler_name
);
2584 LTO_NO_PREVAIL (DECL_SECTION_NAME (t
));
2586 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
2588 LTO_NO_PREVAIL (DECL_ARGUMENT_FLD (t
));
2589 LTO_NO_PREVAIL (DECL_RESULT_FLD (t
));
2590 LTO_NO_PREVAIL (DECL_VINDEX (t
));
2592 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
2593 LTO_SET_PREVAIL (DECL_FUNCTION_PERSONALITY (t
));
2594 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
2596 LTO_SET_PREVAIL (DECL_FIELD_OFFSET (t
));
2597 LTO_NO_PREVAIL (DECL_BIT_FIELD_TYPE (t
));
2598 LTO_NO_PREVAIL (DECL_QUALIFIER (t
));
2599 LTO_NO_PREVAIL (DECL_FIELD_BIT_OFFSET (t
));
2600 LTO_NO_PREVAIL (DECL_FCONTEXT (t
));
2603 else if (TYPE_P (t
))
2605 LTO_NO_PREVAIL (TYPE_CACHED_VALUES (t
));
2606 LTO_SET_PREVAIL (TYPE_SIZE (t
));
2607 LTO_SET_PREVAIL (TYPE_SIZE_UNIT (t
));
2608 LTO_NO_PREVAIL (TYPE_ATTRIBUTES (t
));
2609 LTO_NO_PREVAIL (TYPE_NAME (t
));
2611 LTO_SET_PREVAIL (TYPE_MINVAL (t
));
2612 LTO_SET_PREVAIL (TYPE_MAXVAL (t
));
2613 LTO_NO_PREVAIL (t
->type_non_common
.binfo
);
2615 LTO_SET_PREVAIL (TYPE_CONTEXT (t
));
2617 LTO_NO_PREVAIL (TYPE_CANONICAL (t
));
2618 LTO_NO_PREVAIL (TYPE_MAIN_VARIANT (t
));
2619 LTO_NO_PREVAIL (TYPE_NEXT_VARIANT (t
));
2621 else if (EXPR_P (t
))
2624 for (i
= TREE_OPERAND_LENGTH (t
) - 1; i
>= 0; --i
)
2625 LTO_SET_PREVAIL (TREE_OPERAND (t
, i
));
2632 LTO_SET_PREVAIL (TREE_VALUE (t
));
2633 LTO_SET_PREVAIL (TREE_PURPOSE (t
));
2634 LTO_NO_PREVAIL (TREE_PURPOSE (t
));
2640 /* If we fixed nothing, then we missed something seen by
2642 gcc_checking_assert (fixed
);
2644 #undef LTO_SET_PREVAIL
2645 #undef LTO_NO_PREVAIL
2647 /* Helper function of lto_fixup_decls. Walks the var and fn streams in STATE,
2648 replaces var and function decls with the corresponding prevailing def. */
2651 lto_fixup_state (struct lto_in_decl_state
*state
)
2654 struct lto_tree_ref_table
*table
;
2656 /* Although we only want to replace FUNCTION_DECLs and VAR_DECLs,
2657 we still need to walk from all DECLs to find the reachable
2658 FUNCTION_DECLs and VAR_DECLs. */
2659 for (si
= 0; si
< LTO_N_DECL_STREAMS
; si
++)
2661 table
= &state
->streams
[si
];
2662 for (i
= 0; i
< table
->size
; i
++)
2664 tree
*tp
= table
->trees
+ i
;
2665 if (VAR_OR_FUNCTION_DECL_P (*tp
)
2666 && (TREE_PUBLIC (*tp
) || DECL_EXTERNAL (*tp
)))
2667 *tp
= lto_symtab_prevailing_decl (*tp
);
2672 /* A callback of htab_traverse. Just extracts a state from SLOT
2673 and calls lto_fixup_state. */
2676 lto_fixup_state_aux (void **slot
, void *aux ATTRIBUTE_UNUSED
)
2678 struct lto_in_decl_state
*state
= (struct lto_in_decl_state
*) *slot
;
2679 lto_fixup_state (state
);
2683 /* Fix the decls from all FILES. Replaces each decl with the corresponding
2687 lto_fixup_decls (struct lto_file_decl_data
**files
)
2693 FOR_EACH_VEC_ELT ((*tree_with_vars
), i
, t
)
2694 lto_fixup_prevailing_decls (t
);
2696 for (i
= 0; files
[i
]; i
++)
2698 struct lto_file_decl_data
*file
= files
[i
];
2699 struct lto_in_decl_state
*state
= file
->global_decl_state
;
2700 lto_fixup_state (state
);
2702 htab_traverse (file
->function_decl_states
, lto_fixup_state_aux
, NULL
);
2706 static GTY((length ("lto_stats.num_input_files + 1"))) struct lto_file_decl_data
**all_file_decl_data
;
2708 /* Turn file datas for sub files into a single array, so that they look
2709 like separate files for further passes. */
2712 lto_flatten_files (struct lto_file_decl_data
**orig
, int count
, int last_file_ix
)
2714 struct lto_file_decl_data
*n
, *next
;
2717 lto_stats
.num_input_files
= count
;
2719 = ggc_alloc_cleared_vec_lto_file_decl_data_ptr (count
+ 1);
2720 /* Set the hooks so that all of the ipa passes can read in their data. */
2721 lto_set_in_hooks (all_file_decl_data
, get_section_data
, free_section_data
);
2722 for (i
= 0, k
= 0; i
< last_file_ix
; i
++)
2724 for (n
= orig
[i
]; n
!= NULL
; n
= next
)
2726 all_file_decl_data
[k
++] = n
;
2731 all_file_decl_data
[k
] = NULL
;
2732 gcc_assert (k
== count
);
2735 /* Input file data before flattening (i.e. splitting them to subfiles to support
2736 incremental linking. */
2737 static int real_file_count
;
2738 static GTY((length ("real_file_count + 1"))) struct lto_file_decl_data
**real_file_decl_data
;
2740 static void print_lto_report_1 (void);
2742 /* Read all the symbols from the input files FNAMES. NFILES is the
2743 number of files requested in the command line. Instantiate a
2744 global call graph by aggregating all the sub-graphs found in each
2748 read_cgraph_and_symbols (unsigned nfiles
, const char **fnames
)
2750 unsigned int i
, last_file_ix
;
2753 struct lto_file_decl_data
**decl_data
;
2759 timevar_push (TV_IPA_LTO_DECL_IN
);
2762 = decl_data
= ggc_alloc_cleared_vec_lto_file_decl_data_ptr (nfiles
+ 1);
2763 real_file_count
= nfiles
;
2765 /* Read the resolution file. */
2767 if (resolution_file_name
)
2770 unsigned num_objects
;
2772 resolution
= fopen (resolution_file_name
, "r");
2773 if (resolution
== NULL
)
2774 fatal_error ("could not open symbol resolution file: %m");
2776 t
= fscanf (resolution
, "%u", &num_objects
);
2777 gcc_assert (t
== 1);
2779 /* True, since the plugin splits the archives. */
2780 gcc_assert (num_objects
== nfiles
);
2782 cgraph_state
= CGRAPH_LTO_STREAMING
;
2784 canonical_type_hash_cache
= new pointer_map
<hashval_t
>;
2785 gimple_canonical_types
= htab_create_ggc (16381, gimple_canonical_type_hash
,
2786 gimple_canonical_type_eq
, 0);
2787 gcc_obstack_init (&tree_scc_hash_obstack
);
2788 tree_scc_hash
.create (4096);
2790 /* Register the common node types with the canonical type machinery so
2791 we properly share alias-sets across languages and TUs. Do not
2792 expose the common nodes as type merge target - those that should be
2793 are already exposed so by pre-loading the LTO streamer caches.
2794 Do two passes - first clear TYPE_CANONICAL and then re-compute it. */
2795 for (i
= 0; i
< itk_none
; ++i
)
2796 lto_register_canonical_types (integer_types
[i
], true);
2797 for (i
= 0; i
< stk_type_kind_last
; ++i
)
2798 lto_register_canonical_types (sizetype_tab
[i
], true);
2799 for (i
= 0; i
< TI_MAX
; ++i
)
2800 lto_register_canonical_types (global_trees
[i
], true);
2801 for (i
= 0; i
< itk_none
; ++i
)
2802 lto_register_canonical_types (integer_types
[i
], false);
2803 for (i
= 0; i
< stk_type_kind_last
; ++i
)
2804 lto_register_canonical_types (sizetype_tab
[i
], false);
2805 for (i
= 0; i
< TI_MAX
; ++i
)
2806 lto_register_canonical_types (global_trees
[i
], false);
2809 fprintf (stderr
, "Reading object files:");
2811 /* Read all of the object files specified on the command line. */
2812 for (i
= 0, last_file_ix
= 0; i
< nfiles
; ++i
)
2814 struct lto_file_decl_data
*file_data
= NULL
;
2817 fprintf (stderr
, " %s", fnames
[i
]);
2821 current_lto_file
= lto_obj_file_open (fnames
[i
], false);
2822 if (!current_lto_file
)
2825 file_data
= lto_file_read (current_lto_file
, resolution
, &count
);
2828 lto_obj_file_close (current_lto_file
);
2829 free (current_lto_file
);
2830 current_lto_file
= NULL
;
2834 decl_data
[last_file_ix
++] = file_data
;
2836 lto_obj_file_close (current_lto_file
);
2837 free (current_lto_file
);
2838 current_lto_file
= NULL
;
2841 lto_flatten_files (decl_data
, count
, last_file_ix
);
2842 lto_stats
.num_input_files
= count
;
2843 ggc_free(decl_data
);
2844 real_file_decl_data
= NULL
;
2846 if (resolution_file_name
)
2847 fclose (resolution
);
2849 /* Show the LTO report before launching LTRANS. */
2850 if (flag_lto_report
|| (flag_wpa
&& flag_lto_report_wpa
))
2851 print_lto_report_1 ();
2853 /* Free gimple type merging datastructures. */
2854 tree_scc_hash
.dispose ();
2855 obstack_free (&tree_scc_hash_obstack
, NULL
);
2856 htab_delete (gimple_canonical_types
);
2857 gimple_canonical_types
= NULL
;
2858 delete canonical_type_hash_cache
;
2859 canonical_type_hash_cache
= NULL
;
2862 /* Set the hooks so that all of the ipa passes can read in their data. */
2863 lto_set_in_hooks (all_file_decl_data
, get_section_data
, free_section_data
);
2865 timevar_pop (TV_IPA_LTO_DECL_IN
);
2868 fprintf (stderr
, "\nReading the callgraph\n");
2870 timevar_push (TV_IPA_LTO_CGRAPH_IO
);
2871 /* Read the symtab. */
2874 /* Store resolutions into the symbol table. */
2876 FOR_EACH_SYMBOL (snode
)
2877 if (symtab_real_symbol_p (snode
)
2878 && snode
->lto_file_data
2879 && snode
->lto_file_data
->resolution_map
2880 && (res
= pointer_map_contains (snode
->lto_file_data
->resolution_map
,
2883 = (enum ld_plugin_symbol_resolution
)(size_t)*res
;
2884 for (i
= 0; all_file_decl_data
[i
]; i
++)
2885 if (all_file_decl_data
[i
]->resolution_map
)
2887 pointer_map_destroy (all_file_decl_data
[i
]->resolution_map
);
2888 all_file_decl_data
[i
]->resolution_map
= NULL
;
2891 timevar_pop (TV_IPA_LTO_CGRAPH_IO
);
2894 fprintf (stderr
, "Merging declarations\n");
2896 timevar_push (TV_IPA_LTO_DECL_MERGE
);
2897 /* Merge global decls. In ltrans mode we read merged cgraph, we do not
2898 need to care about resolving symbols again, we only need to replace
2899 duplicated declarations read from the callgraph and from function
2903 lto_symtab_merge_decls ();
2905 /* If there were errors during symbol merging bail out, we have no
2906 good way to recover here. */
2908 fatal_error ("errors during merging of translation units");
2910 /* Fixup all decls. */
2911 lto_fixup_decls (all_file_decl_data
);
2914 ggc_free (tree_with_vars
);
2915 tree_with_vars
= NULL
;
2918 timevar_pop (TV_IPA_LTO_DECL_MERGE
);
2919 /* Each pass will set the appropriate timer. */
2922 fprintf (stderr
, "Reading summaries\n");
2924 /* Read the IPA summary data. */
2926 ipa_read_optimization_summaries ();
2928 ipa_read_summaries ();
2930 for (i
= 0; all_file_decl_data
[i
]; i
++)
2932 gcc_assert (all_file_decl_data
[i
]->symtab_node_encoder
);
2933 lto_symtab_encoder_delete (all_file_decl_data
[i
]->symtab_node_encoder
);
2934 all_file_decl_data
[i
]->symtab_node_encoder
= NULL
;
2935 lto_free_function_in_decl_state (all_file_decl_data
[i
]->global_decl_state
);
2936 all_file_decl_data
[i
]->global_decl_state
= NULL
;
2937 all_file_decl_data
[i
]->current_decl_state
= NULL
;
2940 /* Finally merge the cgraph according to the decl merging decisions. */
2941 timevar_push (TV_IPA_LTO_CGRAPH_MERGE
);
2942 if (cgraph_dump_file
)
2944 fprintf (cgraph_dump_file
, "Before merging:\n");
2945 dump_symtab (cgraph_dump_file
);
2947 lto_symtab_merge_symbols ();
2949 cgraph_state
= CGRAPH_STATE_IPA_SSA
;
2951 timevar_pop (TV_IPA_LTO_CGRAPH_MERGE
);
2953 timevar_push (TV_IPA_LTO_DECL_INIT_IO
);
2955 /* Indicate that the cgraph is built and ready. */
2956 cgraph_function_flags_ready
= true;
2958 timevar_pop (TV_IPA_LTO_DECL_INIT_IO
);
2959 ggc_free (all_file_decl_data
);
2960 all_file_decl_data
= NULL
;
2964 /* Materialize all the bodies for all the nodes in the callgraph. */
2967 materialize_cgraph (void)
2970 struct cgraph_node
*node
;
2972 timevar_id_t lto_timer
;
2976 flag_wpa
? "Materializing decls:" : "Reading function bodies:");
2978 /* Now that we have input the cgraph, we need to clear all of the aux
2979 nodes and read the functions if we are not running in WPA mode. */
2980 timevar_push (TV_IPA_LTO_GIMPLE_IN
);
2982 FOR_EACH_FUNCTION (node
)
2984 if (node
->lto_file_data
)
2986 lto_materialize_function (node
);
2987 lto_stats
.num_input_cgraph_nodes
++;
2991 timevar_pop (TV_IPA_LTO_GIMPLE_IN
);
2993 /* Start the appropriate timer depending on the mode that we are
2995 lto_timer
= (flag_wpa
) ? TV_WHOPR_WPA
2996 : (flag_ltrans
) ? TV_WHOPR_LTRANS
2998 timevar_push (lto_timer
);
3000 current_function_decl
= NULL
;
3003 /* Inform the middle end about the global variables we have seen. */
3004 FOR_EACH_VEC_ELT (*lto_global_var_decls
, i
, decl
)
3005 rest_of_decl_compilation (decl
, 1, 0);
3008 fprintf (stderr
, "\n");
3010 timevar_pop (lto_timer
);
3014 /* Show various memory usage statistics related to LTO. */
3016 print_lto_report_1 (void)
3018 const char *pfx
= (flag_lto
) ? "LTO" : (flag_wpa
) ? "WPA" : "LTRANS";
3019 fprintf (stderr
, "%s statistics\n", pfx
);
3021 fprintf (stderr
, "[%s] read %lu SCCs of average size %f\n",
3022 pfx
, num_sccs_read
, total_scc_size
/ (double)num_sccs_read
);
3023 fprintf (stderr
, "[%s] %lu tree bodies read in total\n", pfx
, total_scc_size
);
3024 if (flag_wpa
&& tree_scc_hash
.is_created ())
3026 fprintf (stderr
, "[%s] tree SCC table: size %ld, %ld elements, "
3027 "collision ratio: %f\n", pfx
,
3028 (long) tree_scc_hash
.size (),
3029 (long) tree_scc_hash
.elements (),
3030 tree_scc_hash
.collisions ());
3031 hash_table
<tree_scc_hasher
>::iterator hiter
;
3032 tree_scc
*scc
, *max_scc
= NULL
;
3033 unsigned max_length
= 0;
3034 FOR_EACH_HASH_TABLE_ELEMENT (tree_scc_hash
, scc
, x
, hiter
)
3036 unsigned length
= 0;
3038 for (; s
; s
= s
->next
)
3040 if (length
> max_length
)
3042 max_length
= length
;
3046 fprintf (stderr
, "[%s] tree SCC max chain length %u (size %u)\n",
3047 pfx
, max_length
, max_scc
->len
);
3048 fprintf (stderr
, "[%s] Compared %lu SCCs, %lu collisions (%f)\n", pfx
,
3049 num_scc_compares
, num_scc_compare_collisions
,
3050 num_scc_compare_collisions
/ (double) num_scc_compares
);
3051 fprintf (stderr
, "[%s] Merged %lu SCCs\n", pfx
, num_sccs_merged
);
3052 fprintf (stderr
, "[%s] Merged %lu tree bodies\n", pfx
,
3053 total_scc_size_merged
);
3054 fprintf (stderr
, "[%s] Merged %lu types\n", pfx
, num_merged_types
);
3055 fprintf (stderr
, "[%s] %lu types prevailed (%lu associated trees)\n",
3056 pfx
, num_prevailing_types
, num_type_scc_trees
);
3057 fprintf (stderr
, "[%s] GIMPLE canonical type table: size %ld, "
3058 "%ld elements, %ld searches, %ld collisions (ratio: %f)\n", pfx
,
3059 (long) htab_size (gimple_canonical_types
),
3060 (long) htab_elements (gimple_canonical_types
),
3061 (long) gimple_canonical_types
->searches
,
3062 (long) gimple_canonical_types
->collisions
,
3063 htab_collisions (gimple_canonical_types
));
3064 fprintf (stderr
, "[%s] GIMPLE canonical type pointer-map: "
3065 "%lu elements, %ld searches\n", pfx
,
3066 num_canonical_type_hash_entries
,
3067 num_canonical_type_hash_queries
);
3070 print_lto_report (pfx
);
3073 /* Perform whole program analysis (WPA) on the callgraph and write out the
3074 optimization plan. */
3077 do_whole_program_analysis (void)
3081 timevar_start (TV_PHASE_OPT_GEN
);
3083 /* Note that since we are in WPA mode, materialize_cgraph will not
3084 actually read in all the function bodies. It only materializes
3085 the decls and cgraph nodes so that analysis can be performed. */
3086 materialize_cgraph ();
3088 /* Reading in the cgraph uses different timers, start timing WPA now. */
3089 timevar_push (TV_WHOPR_WPA
);
3091 if (pre_ipa_mem_report
)
3093 fprintf (stderr
, "Memory consumption before IPA\n");
3094 dump_memory_report (false);
3097 cgraph_function_flags_ready
= true;
3099 if (cgraph_dump_file
)
3100 dump_symtab (cgraph_dump_file
);
3101 bitmap_obstack_initialize (NULL
);
3102 cgraph_state
= CGRAPH_STATE_IPA_SSA
;
3104 execute_ipa_pass_list (g
->get_passes ()->all_regular_ipa_passes
);
3105 symtab_remove_unreachable_nodes (false, dump_file
);
3107 if (cgraph_dump_file
)
3109 fprintf (cgraph_dump_file
, "Optimized ");
3110 dump_symtab (cgraph_dump_file
);
3112 #ifdef ENABLE_CHECKING
3115 bitmap_obstack_release (NULL
);
3117 /* We are about to launch the final LTRANS phase, stop the WPA timer. */
3118 timevar_pop (TV_WHOPR_WPA
);
3120 timevar_push (TV_WHOPR_PARTITIONING
);
3121 if (flag_lto_partition_1to1
)
3123 else if (flag_lto_partition_max
)
3126 lto_balanced_map ();
3128 /* AUX pointers are used by partitioning code to bookkeep number of
3129 partitions symbol is in. This is no longer needed. */
3130 FOR_EACH_SYMBOL (node
)
3133 lto_stats
.num_cgraph_partitions
+= ltrans_partitions
.length ();
3134 timevar_pop (TV_WHOPR_PARTITIONING
);
3136 timevar_stop (TV_PHASE_OPT_GEN
);
3137 timevar_start (TV_PHASE_STREAM_OUT
);
3141 fprintf (stderr
, "\nStreaming out");
3144 lto_wpa_write_files ();
3146 fprintf (stderr
, "\n");
3148 timevar_stop (TV_PHASE_STREAM_OUT
);
3151 if (post_ipa_mem_report
)
3153 fprintf (stderr
, "Memory consumption after IPA\n");
3154 dump_memory_report (false);
3157 /* Show the LTO report before launching LTRANS. */
3158 if (flag_lto_report
|| (flag_wpa
&& flag_lto_report_wpa
))
3159 print_lto_report_1 ();
3161 dump_memory_report (true);
3165 static GTY(()) tree lto_eh_personality_decl
;
3167 /* Return the LTO personality function decl. */
3170 lto_eh_personality (void)
3172 if (!lto_eh_personality_decl
)
3174 /* Use the first personality DECL for our personality if we don't
3175 support multiple ones. This ensures that we don't artificially
3176 create the need for them in a single-language program. */
3177 if (first_personality_decl
&& !dwarf2out_do_cfi_asm ())
3178 lto_eh_personality_decl
= first_personality_decl
;
3180 lto_eh_personality_decl
= lhd_gcc_personality ();
3183 return lto_eh_personality_decl
;
3186 /* Set the process name based on the LTO mode. */
3189 lto_process_name (void)
3192 setproctitle ("lto1-lto");
3194 setproctitle ("lto1-wpa");
3196 setproctitle ("lto1-ltrans");
3200 /* Initialize the LTO front end. */
3205 lto_process_name ();
3206 lto_streamer_hooks_init ();
3208 lto_set_in_hooks (NULL
, get_section_data
, free_section_data
);
3209 memset (<o_stats
, 0, sizeof (lto_stats
));
3210 bitmap_obstack_initialize (NULL
);
3211 gimple_register_cfg_hooks ();
3215 /* Main entry point for the GIMPLE front end. This front end has
3216 three main personalities:
3218 - LTO (-flto). All the object files on the command line are
3219 loaded in memory and processed as a single translation unit.
3220 This is the traditional link-time optimization behavior.
3222 - WPA (-fwpa). Only the callgraph and summary information for
3223 files in the command file are loaded. A single callgraph
3224 (without function bodies) is instantiated for the whole set of
3225 files. IPA passes are only allowed to analyze the call graph
3226 and make transformation decisions. The callgraph is
3227 partitioned, each partition is written to a new object file
3228 together with the transformation decisions.
3230 - LTRANS (-fltrans). Similar to -flto but it prevents the IPA
3231 summary files from running again. Since WPA computed summary
3232 information and decided what transformations to apply, LTRANS
3233 simply applies them. */
3238 /* LTO is called as a front end, even though it is not a front end.
3239 Because it is called as a front end, TV_PHASE_PARSING and
3240 TV_PARSE_GLOBAL are active, and we need to turn them off while
3241 doing LTO. Later we turn them back on so they are active up in
3243 timevar_pop (TV_PARSE_GLOBAL
);
3244 timevar_stop (TV_PHASE_PARSING
);
3246 timevar_start (TV_PHASE_SETUP
);
3248 /* Initialize the LTO front end. */
3251 timevar_stop (TV_PHASE_SETUP
);
3252 timevar_start (TV_PHASE_STREAM_IN
);
3254 /* Read all the symbols and call graph from all the files in the
3256 read_cgraph_and_symbols (num_in_fnames
, in_fnames
);
3258 timevar_stop (TV_PHASE_STREAM_IN
);
3262 /* If WPA is enabled analyze the whole call graph and create an
3263 optimization plan. Otherwise, read in all the function
3264 bodies and continue with optimization. */
3266 do_whole_program_analysis ();
3269 struct varpool_node
*vnode
;
3271 timevar_start (TV_PHASE_OPT_GEN
);
3273 materialize_cgraph ();
3275 lto_promote_statics_nonwpa ();
3277 /* Let the middle end know that we have read and merged all of
3281 timevar_stop (TV_PHASE_OPT_GEN
);
3283 /* FIXME lto, if the processes spawned by WPA fail, we miss
3284 the chance to print WPA's report, so WPA will call
3285 print_lto_report before launching LTRANS. If LTRANS was
3286 launched directly by the driver we would not need to do
3288 if (flag_lto_report
|| (flag_wpa
&& flag_lto_report_wpa
))
3289 print_lto_report_1 ();
3291 /* Record the global variables. */
3292 FOR_EACH_DEFINED_VARIABLE (vnode
)
3293 vec_safe_push (lto_global_var_decls
, vnode
->decl
);
3297 /* Here we make LTO pretend to be a parser. */
3298 timevar_start (TV_PHASE_PARSING
);
3299 timevar_push (TV_PARSE_GLOBAL
);
3302 #include "gt-lto-lto.h"