1 /* Top-level LTO routines.
2 Copyright (C) 2009-2018 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 "basic-block.h"
31 #include "alloc-pool.h"
32 #include "tree-pass.h"
33 #include "tree-streamer.h"
37 #include "stor-layout.h"
38 #include "symbol-summary.h"
44 #include "lto-section-names.h"
45 #include "splay-tree.h"
46 #include "lto-partition.h"
48 #include "pass_manager.h"
49 #include "ipa-fnsummary.h"
51 #include "ipa-utils.h"
52 #include "gomp-constants.h"
53 #include "lto-symtab.h"
54 #include "stringpool.h"
55 #include "fold-const.h"
60 /* Number of parallel tasks to run, -1 if we want to use GNU Make jobserver. */
61 static int lto_parallelism
;
63 static GTY(()) tree first_personality_decl
;
65 static GTY(()) const unsigned char *lto_mode_identity_table
;
67 /* Returns a hash code for P. */
70 hash_name (const void *p
)
72 const struct lto_section_slot
*ds
= (const struct lto_section_slot
*) p
;
73 return (hashval_t
) htab_hash_string (ds
->name
);
77 /* Returns nonzero if P1 and P2 are equal. */
80 eq_name (const void *p1
, const void *p2
)
82 const struct lto_section_slot
*s1
=
83 (const struct lto_section_slot
*) p1
;
84 const struct lto_section_slot
*s2
=
85 (const struct lto_section_slot
*) p2
;
87 return strcmp (s1
->name
, s2
->name
) == 0;
90 /* Free lto_section_slot */
93 free_with_string (void *arg
)
95 struct lto_section_slot
*s
= (struct lto_section_slot
*)arg
;
97 free (CONST_CAST (char *, s
->name
));
101 /* Create section hash table */
104 lto_obj_create_section_hash_table (void)
106 return htab_create (37, hash_name
, eq_name
, free_with_string
);
109 /* Delete an allocated integer KEY in the splay tree. */
112 lto_splay_tree_delete_id (splay_tree_key key
)
117 /* Compare splay tree node ids A and B. */
120 lto_splay_tree_compare_ids (splay_tree_key a
, splay_tree_key b
)
122 unsigned HOST_WIDE_INT ai
;
123 unsigned HOST_WIDE_INT bi
;
125 ai
= *(unsigned HOST_WIDE_INT
*) a
;
126 bi
= *(unsigned HOST_WIDE_INT
*) b
;
135 /* Look up splay tree node by ID in splay tree T. */
137 static splay_tree_node
138 lto_splay_tree_lookup (splay_tree t
, unsigned HOST_WIDE_INT id
)
140 return splay_tree_lookup (t
, (splay_tree_key
) &id
);
143 /* Check if KEY has ID. */
146 lto_splay_tree_id_equal_p (splay_tree_key key
, unsigned HOST_WIDE_INT id
)
148 return *(unsigned HOST_WIDE_INT
*) key
== id
;
151 /* Insert a splay tree node into tree T with ID as key and FILE_DATA as value.
152 The ID is allocated separately because we need HOST_WIDE_INTs which may
153 be wider than a splay_tree_key. */
156 lto_splay_tree_insert (splay_tree t
, unsigned HOST_WIDE_INT id
,
157 struct lto_file_decl_data
*file_data
)
159 unsigned HOST_WIDE_INT
*idp
= XCNEW (unsigned HOST_WIDE_INT
);
161 splay_tree_insert (t
, (splay_tree_key
) idp
, (splay_tree_value
) file_data
);
164 /* Create a splay tree. */
167 lto_splay_tree_new (void)
169 return splay_tree_new (lto_splay_tree_compare_ids
,
170 lto_splay_tree_delete_id
,
174 /* Return true when NODE has a clone that is analyzed (i.e. we need
175 to load its body even if the node itself is not needed). */
178 has_analyzed_clone_p (struct cgraph_node
*node
)
180 struct cgraph_node
*orig
= node
;
189 else if (node
->next_sibling_clone
)
190 node
= node
->next_sibling_clone
;
193 while (node
!= orig
&& !node
->next_sibling_clone
)
194 node
= node
->clone_of
;
196 node
= node
->next_sibling_clone
;
202 /* Read the function body for the function associated with NODE. */
205 lto_materialize_function (struct cgraph_node
*node
)
210 /* Read in functions with body (analyzed nodes)
211 and also functions that are needed to produce virtual clones. */
212 if ((node
->has_gimple_body_p () && node
->analyzed
)
213 || node
->used_as_abstract_origin
214 || has_analyzed_clone_p (node
))
216 /* Clones don't need to be read. */
219 if (DECL_FUNCTION_PERSONALITY (decl
) && !first_personality_decl
)
220 first_personality_decl
= DECL_FUNCTION_PERSONALITY (decl
);
223 /* Let the middle end know about the function. */
224 rest_of_decl_compilation (decl
, 1, 0);
228 /* Decode the content of memory pointed to by DATA in the in decl
229 state object STATE. DATA_IN points to a data_in structure for
230 decoding. Return the address after the decoded object in the
233 static const uint32_t *
234 lto_read_in_decl_state (struct data_in
*data_in
, const uint32_t *data
,
235 struct lto_in_decl_state
*state
)
242 state
->compressed
= ix
& 1;
244 decl
= streamer_tree_cache_get_tree (data_in
->reader_cache
, ix
);
245 if (!VAR_OR_FUNCTION_DECL_P (decl
))
247 gcc_assert (decl
== void_type_node
);
250 state
->fn_decl
= decl
;
252 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
254 uint32_t size
= *data
++;
255 vec
<tree
, va_gc
> *decls
= NULL
;
256 vec_alloc (decls
, size
);
258 for (j
= 0; j
< size
; j
++)
259 vec_safe_push (decls
,
260 streamer_tree_cache_get_tree (data_in
->reader_cache
,
263 state
->streams
[i
] = decls
;
271 /* Global canonical type table. */
272 static htab_t gimple_canonical_types
;
273 static hash_map
<const_tree
, hashval_t
> *canonical_type_hash_cache
;
274 static unsigned long num_canonical_type_hash_entries
;
275 static unsigned long num_canonical_type_hash_queries
;
277 static void iterative_hash_canonical_type (tree type
, inchash::hash
&hstate
);
278 static hashval_t
gimple_canonical_type_hash (const void *p
);
279 static void gimple_register_canonical_type_1 (tree t
, hashval_t hash
);
281 /* Returning a hash value for gimple type TYPE.
283 The hash value returned is equal for types considered compatible
284 by gimple_canonical_types_compatible_p. */
287 hash_canonical_type (tree type
)
289 inchash::hash hstate
;
292 /* We compute alias sets only for types that needs them.
293 Be sure we do not recurse to something else as we can not hash incomplete
294 types in a way they would have same hash value as compatible complete
296 gcc_checking_assert (type_with_alias_set_p (type
));
298 /* Combine a few common features of types so that types are grouped into
299 smaller sets; when searching for existing matching types to merge,
300 only existing types having the same features as the new type will be
302 code
= tree_code_for_canonical_type_merging (TREE_CODE (type
));
303 hstate
.add_int (code
);
304 hstate
.add_int (TYPE_MODE (type
));
306 /* Incorporate common features of numerical types. */
307 if (INTEGRAL_TYPE_P (type
)
308 || SCALAR_FLOAT_TYPE_P (type
)
309 || FIXED_POINT_TYPE_P (type
)
310 || TREE_CODE (type
) == OFFSET_TYPE
311 || POINTER_TYPE_P (type
))
313 hstate
.add_int (TYPE_PRECISION (type
));
314 if (!type_with_interoperable_signedness (type
))
315 hstate
.add_int (TYPE_UNSIGNED (type
));
318 if (VECTOR_TYPE_P (type
))
320 hstate
.add_poly_int (TYPE_VECTOR_SUBPARTS (type
));
321 hstate
.add_int (TYPE_UNSIGNED (type
));
324 if (TREE_CODE (type
) == COMPLEX_TYPE
)
325 hstate
.add_int (TYPE_UNSIGNED (type
));
327 /* Fortran's C_SIGNED_CHAR is !TYPE_STRING_FLAG but needs to be
328 interoperable with "signed char". Unless all frontends are revisited to
329 agree on these types, we must ignore the flag completely. */
331 /* Fortran standard define C_PTR type that is compatible with every
332 C pointer. For this reason we need to glob all pointers into one.
333 Still pointers in different address spaces are not compatible. */
334 if (POINTER_TYPE_P (type
))
335 hstate
.add_int (TYPE_ADDR_SPACE (TREE_TYPE (type
)));
337 /* For array types hash the domain bounds and the string flag. */
338 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
340 hstate
.add_int (TYPE_STRING_FLAG (type
));
341 /* OMP lowering can introduce error_mark_node in place of
342 random local decls in types. */
343 if (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)) != error_mark_node
)
344 inchash::add_expr (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)), hstate
);
345 if (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != error_mark_node
)
346 inchash::add_expr (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)), hstate
);
349 /* Recurse for aggregates with a single element type. */
350 if (TREE_CODE (type
) == ARRAY_TYPE
351 || TREE_CODE (type
) == COMPLEX_TYPE
352 || TREE_CODE (type
) == VECTOR_TYPE
)
353 iterative_hash_canonical_type (TREE_TYPE (type
), hstate
);
355 /* Incorporate function return and argument types. */
356 if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
361 iterative_hash_canonical_type (TREE_TYPE (type
), hstate
);
363 for (p
= TYPE_ARG_TYPES (type
), na
= 0; p
; p
= TREE_CHAIN (p
))
365 iterative_hash_canonical_type (TREE_VALUE (p
), hstate
);
372 if (RECORD_OR_UNION_TYPE_P (type
))
377 for (f
= TYPE_FIELDS (type
), nf
= 0; f
; f
= TREE_CHAIN (f
))
378 if (TREE_CODE (f
) == FIELD_DECL
380 || ! integer_zerop (DECL_SIZE (f
))))
382 iterative_hash_canonical_type (TREE_TYPE (f
), hstate
);
392 /* Returning a hash value for gimple type TYPE combined with VAL. */
395 iterative_hash_canonical_type (tree type
, inchash::hash
&hstate
)
399 /* All type variants have same TYPE_CANONICAL. */
400 type
= TYPE_MAIN_VARIANT (type
);
402 if (!canonical_type_used_p (type
))
403 v
= hash_canonical_type (type
);
404 /* An already processed type. */
405 else if (TYPE_CANONICAL (type
))
407 type
= TYPE_CANONICAL (type
);
408 v
= gimple_canonical_type_hash (type
);
412 /* Canonical types should not be able to form SCCs by design, this
413 recursion is just because we do not register canonical types in
414 optimal order. To avoid quadratic behavior also register the
416 v
= hash_canonical_type (type
);
417 gimple_register_canonical_type_1 (type
, v
);
422 /* Returns the hash for a canonical type P. */
425 gimple_canonical_type_hash (const void *p
)
427 num_canonical_type_hash_queries
++;
428 hashval_t
*slot
= canonical_type_hash_cache
->get ((const_tree
) p
);
429 gcc_assert (slot
!= NULL
);
435 /* Returns nonzero if P1 and P2 are equal. */
438 gimple_canonical_type_eq (const void *p1
, const void *p2
)
440 const_tree t1
= (const_tree
) p1
;
441 const_tree t2
= (const_tree
) p2
;
442 return gimple_canonical_types_compatible_p (CONST_CAST_TREE (t1
),
443 CONST_CAST_TREE (t2
));
446 /* Main worker for gimple_register_canonical_type. */
449 gimple_register_canonical_type_1 (tree t
, hashval_t hash
)
453 gcc_checking_assert (TYPE_P (t
) && !TYPE_CANONICAL (t
)
454 && type_with_alias_set_p (t
)
455 && canonical_type_used_p (t
));
457 slot
= htab_find_slot_with_hash (gimple_canonical_types
, t
, hash
, INSERT
);
460 tree new_type
= (tree
)(*slot
);
461 gcc_checking_assert (new_type
!= t
);
462 TYPE_CANONICAL (t
) = new_type
;
466 TYPE_CANONICAL (t
) = t
;
468 /* Cache the just computed hash value. */
469 num_canonical_type_hash_entries
++;
470 bool existed_p
= canonical_type_hash_cache
->put (t
, hash
);
471 gcc_assert (!existed_p
);
475 /* Register type T in the global type table gimple_types and set
476 TYPE_CANONICAL of T accordingly.
477 This is used by LTO to merge structurally equivalent types for
478 type-based aliasing purposes across different TUs and languages.
480 ??? This merging does not exactly match how the tree.c middle-end
481 functions will assign TYPE_CANONICAL when new types are created
482 during optimization (which at least happens for pointer and array
486 gimple_register_canonical_type (tree t
)
488 if (TYPE_CANONICAL (t
) || !type_with_alias_set_p (t
)
489 || !canonical_type_used_p (t
))
492 /* Canonical types are same among all complete variants. */
493 if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (t
)))
494 TYPE_CANONICAL (t
) = TYPE_CANONICAL (TYPE_MAIN_VARIANT (t
));
497 gimple_register_canonical_type_1 (TYPE_MAIN_VARIANT (t
),
498 hash_canonical_type (TYPE_MAIN_VARIANT (t
)));
499 TYPE_CANONICAL (t
) = TYPE_CANONICAL (TYPE_MAIN_VARIANT (t
));
503 /* Re-compute TYPE_CANONICAL for NODE and related types. */
506 lto_register_canonical_types (tree node
, bool first_p
)
513 TYPE_CANONICAL (node
) = NULL_TREE
;
515 if (POINTER_TYPE_P (node
)
516 || TREE_CODE (node
) == COMPLEX_TYPE
517 || TREE_CODE (node
) == ARRAY_TYPE
)
518 lto_register_canonical_types (TREE_TYPE (node
), first_p
);
521 gimple_register_canonical_type (node
);
525 /* Remember trees that contains references to declarations. */
526 static GTY(()) vec
<tree
, va_gc
> *tree_with_vars
;
528 #define CHECK_VAR(tt) \
531 if ((tt) && VAR_OR_FUNCTION_DECL_P (tt) \
532 && (TREE_PUBLIC (tt) || DECL_EXTERNAL (tt))) \
536 #define CHECK_NO_VAR(tt) \
537 gcc_checking_assert (!(tt) || !VAR_OR_FUNCTION_DECL_P (tt))
539 /* Check presence of pointers to decls in fields of a tree_typed T. */
542 mentions_vars_p_typed (tree t
)
544 CHECK_NO_VAR (TREE_TYPE (t
));
548 /* Check presence of pointers to decls in fields of a tree_common T. */
551 mentions_vars_p_common (tree t
)
553 if (mentions_vars_p_typed (t
))
555 CHECK_NO_VAR (TREE_CHAIN (t
));
559 /* Check presence of pointers to decls in fields of a decl_minimal T. */
562 mentions_vars_p_decl_minimal (tree t
)
564 if (mentions_vars_p_common (t
))
566 CHECK_NO_VAR (DECL_NAME (t
));
567 CHECK_VAR (DECL_CONTEXT (t
));
571 /* Check presence of pointers to decls in fields of a decl_common T. */
574 mentions_vars_p_decl_common (tree t
)
576 if (mentions_vars_p_decl_minimal (t
))
578 CHECK_VAR (DECL_SIZE (t
));
579 CHECK_VAR (DECL_SIZE_UNIT (t
));
580 CHECK_VAR (DECL_INITIAL (t
));
581 CHECK_NO_VAR (DECL_ATTRIBUTES (t
));
582 CHECK_VAR (DECL_ABSTRACT_ORIGIN (t
));
586 /* Check presence of pointers to decls in fields of a decl_with_vis T. */
589 mentions_vars_p_decl_with_vis (tree t
)
591 if (mentions_vars_p_decl_common (t
))
594 /* Accessor macro has side-effects, use field-name here. */
595 CHECK_NO_VAR (DECL_ASSEMBLER_NAME_RAW (t
));
599 /* Check presence of pointers to decls in fields of a decl_non_common T. */
602 mentions_vars_p_decl_non_common (tree t
)
604 if (mentions_vars_p_decl_with_vis (t
))
606 CHECK_NO_VAR (DECL_RESULT_FLD (t
));
610 /* Check presence of pointers to decls in fields of a decl_non_common T. */
613 mentions_vars_p_function (tree t
)
615 if (mentions_vars_p_decl_non_common (t
))
617 CHECK_NO_VAR (DECL_ARGUMENTS (t
));
618 CHECK_NO_VAR (DECL_VINDEX (t
));
619 CHECK_VAR (DECL_FUNCTION_PERSONALITY (t
));
623 /* Check presence of pointers to decls in fields of a field_decl T. */
626 mentions_vars_p_field_decl (tree t
)
628 if (mentions_vars_p_decl_common (t
))
630 CHECK_VAR (DECL_FIELD_OFFSET (t
));
631 CHECK_NO_VAR (DECL_BIT_FIELD_TYPE (t
));
632 CHECK_NO_VAR (DECL_QUALIFIER (t
));
633 CHECK_NO_VAR (DECL_FIELD_BIT_OFFSET (t
));
634 CHECK_NO_VAR (DECL_FCONTEXT (t
));
638 /* Check presence of pointers to decls in fields of a type T. */
641 mentions_vars_p_type (tree t
)
643 if (mentions_vars_p_common (t
))
645 CHECK_NO_VAR (TYPE_CACHED_VALUES (t
));
646 CHECK_VAR (TYPE_SIZE (t
));
647 CHECK_VAR (TYPE_SIZE_UNIT (t
));
648 CHECK_NO_VAR (TYPE_ATTRIBUTES (t
));
649 CHECK_NO_VAR (TYPE_NAME (t
));
651 CHECK_VAR (TYPE_MIN_VALUE_RAW (t
));
652 CHECK_VAR (TYPE_MAX_VALUE_RAW (t
));
654 /* Accessor is for derived node types only. */
655 CHECK_NO_VAR (TYPE_LANG_SLOT_1 (t
));
657 CHECK_VAR (TYPE_CONTEXT (t
));
658 CHECK_NO_VAR (TYPE_CANONICAL (t
));
659 CHECK_NO_VAR (TYPE_MAIN_VARIANT (t
));
660 CHECK_NO_VAR (TYPE_NEXT_VARIANT (t
));
664 /* Check presence of pointers to decls in fields of a BINFO T. */
667 mentions_vars_p_binfo (tree t
)
669 unsigned HOST_WIDE_INT i
, n
;
671 if (mentions_vars_p_common (t
))
673 CHECK_VAR (BINFO_VTABLE (t
));
674 CHECK_NO_VAR (BINFO_OFFSET (t
));
675 CHECK_NO_VAR (BINFO_VIRTUALS (t
));
676 CHECK_NO_VAR (BINFO_VPTR_FIELD (t
));
677 n
= vec_safe_length (BINFO_BASE_ACCESSES (t
));
678 for (i
= 0; i
< n
; i
++)
679 CHECK_NO_VAR (BINFO_BASE_ACCESS (t
, i
));
680 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
681 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
682 n
= BINFO_N_BASE_BINFOS (t
);
683 for (i
= 0; i
< n
; i
++)
684 CHECK_NO_VAR (BINFO_BASE_BINFO (t
, i
));
688 /* Check presence of pointers to decls in fields of a CONSTRUCTOR T. */
691 mentions_vars_p_constructor (tree t
)
693 unsigned HOST_WIDE_INT idx
;
696 if (mentions_vars_p_typed (t
))
699 for (idx
= 0; vec_safe_iterate (CONSTRUCTOR_ELTS (t
), idx
, &ce
); idx
++)
701 CHECK_NO_VAR (ce
->index
);
702 CHECK_VAR (ce
->value
);
707 /* Check presence of pointers to decls in fields of an expression tree T. */
710 mentions_vars_p_expr (tree t
)
713 if (mentions_vars_p_typed (t
))
715 for (i
= TREE_OPERAND_LENGTH (t
) - 1; i
>= 0; --i
)
716 CHECK_VAR (TREE_OPERAND (t
, i
));
720 /* Check presence of pointers to decls in fields of an OMP_CLAUSE T. */
723 mentions_vars_p_omp_clause (tree t
)
726 if (mentions_vars_p_common (t
))
728 for (i
= omp_clause_num_ops
[OMP_CLAUSE_CODE (t
)] - 1; i
>= 0; --i
)
729 CHECK_VAR (OMP_CLAUSE_OPERAND (t
, i
));
733 /* Check presence of pointers to decls that needs later fixup in T. */
736 mentions_vars_p (tree t
)
738 switch (TREE_CODE (t
))
740 case IDENTIFIER_NODE
:
744 CHECK_VAR (TREE_VALUE (t
));
745 CHECK_VAR (TREE_PURPOSE (t
));
746 CHECK_NO_VAR (TREE_CHAIN (t
));
750 return mentions_vars_p_field_decl (t
);
759 return mentions_vars_p_decl_common (t
);
762 return mentions_vars_p_decl_with_vis (t
);
765 return mentions_vars_p_decl_non_common (t
);
768 return mentions_vars_p_function (t
);
771 return mentions_vars_p_binfo (t
);
773 case PLACEHOLDER_EXPR
:
774 return mentions_vars_p_common (t
);
777 case TRANSLATION_UNIT_DECL
:
778 case OPTIMIZATION_NODE
:
779 case TARGET_OPTION_NODE
:
783 return mentions_vars_p_constructor (t
);
786 return mentions_vars_p_omp_clause (t
);
791 if (mentions_vars_p_type (t
))
796 if (mentions_vars_p_expr (t
))
799 else if (CONSTANT_CLASS_P (t
))
800 CHECK_NO_VAR (TREE_TYPE (t
));
808 /* Return the resolution for the decl with index INDEX from DATA_IN. */
810 static enum ld_plugin_symbol_resolution
811 get_resolution (struct data_in
*data_in
, unsigned index
)
813 if (data_in
->globals_resolution
.exists ())
815 ld_plugin_symbol_resolution_t ret
;
816 /* We can have references to not emitted functions in
817 DECL_FUNCTION_PERSONALITY at least. So we can and have
818 to indeed return LDPR_UNKNOWN in some cases. */
819 if (data_in
->globals_resolution
.length () <= index
)
821 ret
= data_in
->globals_resolution
[index
];
825 /* Delay resolution finding until decl merging. */
829 /* We need to record resolutions until symbol table is read. */
831 register_resolution (struct lto_file_decl_data
*file_data
, tree decl
,
832 enum ld_plugin_symbol_resolution resolution
)
835 if (resolution
== LDPR_UNKNOWN
)
837 if (!file_data
->resolution_map
)
838 file_data
->resolution_map
839 = new hash_map
<tree
, ld_plugin_symbol_resolution
>;
840 ld_plugin_symbol_resolution_t
&res
841 = file_data
->resolution_map
->get_or_insert (decl
, &existed
);
843 || resolution
== LDPR_PREVAILING_DEF_IRONLY
844 || resolution
== LDPR_PREVAILING_DEF
845 || resolution
== LDPR_PREVAILING_DEF_IRONLY_EXP
)
849 /* Register DECL with the global symbol table and change its
850 name if necessary to avoid name clashes for static globals across
854 lto_register_var_decl_in_symtab (struct data_in
*data_in
, tree decl
,
859 /* Variable has file scope, not local. */
860 if (!TREE_PUBLIC (decl
)
861 && !((context
= decl_function_context (decl
))
862 && auto_var_in_fn_p (decl
, context
)))
863 rest_of_decl_compilation (decl
, 1, 0);
865 /* If this variable has already been declared, queue the
866 declaration for merging. */
867 if (TREE_PUBLIC (decl
))
868 register_resolution (data_in
->file_data
,
869 decl
, get_resolution (data_in
, ix
));
873 /* Register DECL with the global symbol table and change its
874 name if necessary to avoid name clashes for static globals across
875 different files. DATA_IN contains descriptors and tables for the
879 lto_register_function_decl_in_symtab (struct data_in
*data_in
, tree decl
,
882 /* If this variable has already been declared, queue the
883 declaration for merging. */
884 if (TREE_PUBLIC (decl
) && !DECL_ABSTRACT_P (decl
))
885 register_resolution (data_in
->file_data
,
886 decl
, get_resolution (data_in
, ix
));
889 /* Check if T is a decl and needs register its resolution info. */
892 lto_maybe_register_decl (struct data_in
*data_in
, tree t
, unsigned ix
)
894 if (TREE_CODE (t
) == VAR_DECL
)
895 lto_register_var_decl_in_symtab (data_in
, t
, ix
);
896 else if (TREE_CODE (t
) == FUNCTION_DECL
897 && !DECL_BUILT_IN (t
))
898 lto_register_function_decl_in_symtab (data_in
, t
, ix
);
902 /* For the type T re-materialize it in the type variant list and
903 the pointer/reference-to chains. */
906 lto_fixup_prevailing_type (tree t
)
908 /* The following re-creates proper variant lists while fixing up
909 the variant leaders. We do not stream TYPE_NEXT_VARIANT so the
910 variant list state before fixup is broken. */
912 /* If we are not our own variant leader link us into our new leaders
914 if (TYPE_MAIN_VARIANT (t
) != t
)
916 tree mv
= TYPE_MAIN_VARIANT (t
);
917 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (mv
);
918 TYPE_NEXT_VARIANT (mv
) = t
;
921 /* The following reconstructs the pointer chains
922 of the new pointed-to type if we are a main variant. We do
923 not stream those so they are broken before fixup. */
924 if (TREE_CODE (t
) == POINTER_TYPE
925 && TYPE_MAIN_VARIANT (t
) == t
)
927 TYPE_NEXT_PTR_TO (t
) = TYPE_POINTER_TO (TREE_TYPE (t
));
928 TYPE_POINTER_TO (TREE_TYPE (t
)) = t
;
930 else if (TREE_CODE (t
) == REFERENCE_TYPE
931 && TYPE_MAIN_VARIANT (t
) == t
)
933 TYPE_NEXT_REF_TO (t
) = TYPE_REFERENCE_TO (TREE_TYPE (t
));
934 TYPE_REFERENCE_TO (TREE_TYPE (t
)) = t
;
939 /* We keep prevailing tree SCCs in a hashtable with manual collision
940 handling (in case all hashes compare the same) and keep the colliding
941 entries in the tree_scc->next chain. */
946 /* Hash of the whole SCC. */
948 /* Number of trees in the SCC. */
950 /* Number of possible entries into the SCC (tree nodes [0..entry_len-1]
951 which share the same individual tree hash). */
953 /* The members of the SCC.
954 We only need to remember the first entry node candidate for prevailing
955 SCCs (but of course have access to all entries for SCCs we are
957 ??? For prevailing SCCs we really only need hash and the first
958 entry candidate, but that's too awkward to implement. */
962 struct tree_scc_hasher
: nofree_ptr_hash
<tree_scc
>
964 static inline hashval_t
hash (const tree_scc
*);
965 static inline bool equal (const tree_scc
*, const tree_scc
*);
969 tree_scc_hasher::hash (const tree_scc
*scc
)
975 tree_scc_hasher::equal (const tree_scc
*scc1
, const tree_scc
*scc2
)
977 if (scc1
->hash
!= scc2
->hash
978 || scc1
->len
!= scc2
->len
979 || scc1
->entry_len
!= scc2
->entry_len
)
984 static hash_table
<tree_scc_hasher
> *tree_scc_hash
;
985 static struct obstack tree_scc_hash_obstack
;
987 static unsigned long num_merged_types
;
988 static unsigned long num_prevailing_types
;
989 static unsigned long num_type_scc_trees
;
990 static unsigned long total_scc_size
;
991 static unsigned long num_sccs_read
;
992 static unsigned long total_scc_size_merged
;
993 static unsigned long num_sccs_merged
;
994 static unsigned long num_scc_compares
;
995 static unsigned long num_scc_compare_collisions
;
998 /* Compare the two entries T1 and T2 of two SCCs that are possibly equal,
999 recursing through in-SCC tree edges. Returns true if the SCCs entered
1000 through T1 and T2 are equal and fills in *MAP with the pairs of
1001 SCC entries we visited, starting with (*MAP)[0] = T1 and (*MAP)[1] = T2. */
1004 compare_tree_sccs_1 (tree t1
, tree t2
, tree
**map
)
1006 enum tree_code code
;
1008 /* Mark already visited nodes. */
1009 TREE_ASM_WRITTEN (t2
) = 1;
1011 /* Push the pair onto map. */
1016 /* Compare value-fields. */
1017 #define compare_values(X) \
1019 if (X(t1) != X(t2)) \
1023 compare_values (TREE_CODE
);
1024 code
= TREE_CODE (t1
);
1028 compare_values (TREE_SIDE_EFFECTS
);
1029 compare_values (TREE_CONSTANT
);
1030 compare_values (TREE_READONLY
);
1031 compare_values (TREE_PUBLIC
);
1033 compare_values (TREE_ADDRESSABLE
);
1034 compare_values (TREE_THIS_VOLATILE
);
1036 compare_values (DECL_UNSIGNED
);
1037 else if (TYPE_P (t1
))
1038 compare_values (TYPE_UNSIGNED
);
1040 compare_values (TYPE_ARTIFICIAL
);
1042 compare_values (TREE_NO_WARNING
);
1043 compare_values (TREE_NOTHROW
);
1044 compare_values (TREE_STATIC
);
1045 if (code
!= TREE_BINFO
)
1046 compare_values (TREE_PRIVATE
);
1047 compare_values (TREE_PROTECTED
);
1048 compare_values (TREE_DEPRECATED
);
1051 if (AGGREGATE_TYPE_P (t1
))
1052 compare_values (TYPE_REVERSE_STORAGE_ORDER
);
1054 compare_values (TYPE_SATURATING
);
1055 compare_values (TYPE_ADDR_SPACE
);
1057 else if (code
== SSA_NAME
)
1058 compare_values (SSA_NAME_IS_DEFAULT_DEF
);
1060 if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
1062 if (wi::to_wide (t1
) != wi::to_wide (t2
))
1066 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
1068 /* ??? No suitable compare routine available. */
1069 REAL_VALUE_TYPE r1
= TREE_REAL_CST (t1
);
1070 REAL_VALUE_TYPE r2
= TREE_REAL_CST (t2
);
1072 || r1
.decimal
!= r2
.decimal
1073 || r1
.sign
!= r2
.sign
1074 || r1
.signalling
!= r2
.signalling
1075 || r1
.canonical
!= r2
.canonical
1076 || r1
.uexp
!= r2
.uexp
)
1078 for (unsigned i
= 0; i
< SIGSZ
; ++i
)
1079 if (r1
.sig
[i
] != r2
.sig
[i
])
1083 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
1084 if (!fixed_compare (EQ_EXPR
,
1085 TREE_FIXED_CST_PTR (t1
), TREE_FIXED_CST_PTR (t2
)))
1088 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
1090 compare_values (VECTOR_CST_LOG2_NPATTERNS
);
1091 compare_values (VECTOR_CST_NELTS_PER_PATTERN
);
1094 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1096 compare_values (DECL_MODE
);
1097 compare_values (DECL_NONLOCAL
);
1098 compare_values (DECL_VIRTUAL_P
);
1099 compare_values (DECL_IGNORED_P
);
1100 compare_values (DECL_ABSTRACT_P
);
1101 compare_values (DECL_ARTIFICIAL
);
1102 compare_values (DECL_USER_ALIGN
);
1103 compare_values (DECL_PRESERVE_P
);
1104 compare_values (DECL_EXTERNAL
);
1105 compare_values (DECL_GIMPLE_REG_P
);
1106 compare_values (DECL_ALIGN
);
1107 if (code
== LABEL_DECL
)
1109 compare_values (EH_LANDING_PAD_NR
);
1110 compare_values (LABEL_DECL_UID
);
1112 else if (code
== FIELD_DECL
)
1114 compare_values (DECL_PACKED
);
1115 compare_values (DECL_NONADDRESSABLE_P
);
1116 compare_values (DECL_PADDING_P
);
1117 compare_values (DECL_OFFSET_ALIGN
);
1119 else if (code
== VAR_DECL
)
1121 compare_values (DECL_HAS_DEBUG_EXPR_P
);
1122 compare_values (DECL_NONLOCAL_FRAME
);
1124 if (code
== RESULT_DECL
1125 || code
== PARM_DECL
1126 || code
== VAR_DECL
)
1128 compare_values (DECL_BY_REFERENCE
);
1129 if (code
== VAR_DECL
1130 || code
== PARM_DECL
)
1131 compare_values (DECL_HAS_VALUE_EXPR_P
);
1135 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
1136 compare_values (DECL_REGISTER
);
1138 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1140 compare_values (DECL_COMMON
);
1141 compare_values (DECL_DLLIMPORT_P
);
1142 compare_values (DECL_WEAK
);
1143 compare_values (DECL_SEEN_IN_BIND_EXPR_P
);
1144 compare_values (DECL_COMDAT
);
1145 compare_values (DECL_VISIBILITY
);
1146 compare_values (DECL_VISIBILITY_SPECIFIED
);
1147 if (code
== VAR_DECL
)
1149 compare_values (DECL_HARD_REGISTER
);
1150 /* DECL_IN_TEXT_SECTION is set during final asm output only. */
1151 compare_values (DECL_IN_CONSTANT_POOL
);
1155 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1157 compare_values (DECL_BUILT_IN_CLASS
);
1158 compare_values (DECL_STATIC_CONSTRUCTOR
);
1159 compare_values (DECL_STATIC_DESTRUCTOR
);
1160 compare_values (DECL_UNINLINABLE
);
1161 compare_values (DECL_POSSIBLY_INLINED
);
1162 compare_values (DECL_IS_NOVOPS
);
1163 compare_values (DECL_IS_RETURNS_TWICE
);
1164 compare_values (DECL_IS_MALLOC
);
1165 compare_values (DECL_IS_OPERATOR_NEW
);
1166 compare_values (DECL_DECLARED_INLINE_P
);
1167 compare_values (DECL_STATIC_CHAIN
);
1168 compare_values (DECL_NO_INLINE_WARNING_P
);
1169 compare_values (DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT
);
1170 compare_values (DECL_NO_LIMIT_STACK
);
1171 compare_values (DECL_DISREGARD_INLINE_LIMITS
);
1172 compare_values (DECL_PURE_P
);
1173 compare_values (DECL_LOOPING_CONST_OR_PURE_P
);
1174 compare_values (DECL_FINAL_P
);
1175 compare_values (DECL_CXX_CONSTRUCTOR_P
);
1176 compare_values (DECL_CXX_DESTRUCTOR_P
);
1177 if (DECL_BUILT_IN_CLASS (t1
) != NOT_BUILT_IN
)
1178 compare_values (DECL_FUNCTION_CODE
);
1181 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
1183 compare_values (TYPE_MODE
);
1184 compare_values (TYPE_STRING_FLAG
);
1185 compare_values (TYPE_NEEDS_CONSTRUCTING
);
1186 if (RECORD_OR_UNION_TYPE_P (t1
))
1188 compare_values (TYPE_TRANSPARENT_AGGR
);
1189 compare_values (TYPE_FINAL_P
);
1191 else if (code
== ARRAY_TYPE
)
1192 compare_values (TYPE_NONALIASED_COMPONENT
);
1193 if (AGGREGATE_TYPE_P (t1
))
1194 compare_values (TYPE_TYPELESS_STORAGE
);
1195 compare_values (TYPE_EMPTY_P
);
1196 compare_values (TYPE_PACKED
);
1197 compare_values (TYPE_RESTRICT
);
1198 compare_values (TYPE_USER_ALIGN
);
1199 compare_values (TYPE_READONLY
);
1200 compare_values (TYPE_PRECISION
);
1201 compare_values (TYPE_ALIGN
);
1202 /* Do not compare TYPE_ALIAS_SET. Doing so introduce ordering issues
1203 with calls to get_alias_set which may initialize it for streamed
1207 /* We don't want to compare locations, so there is nothing do compare
1210 /* BLOCKs are function local and we don't merge anything there, so
1211 simply refuse to merge. */
1212 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
1215 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
1216 if (strcmp (TRANSLATION_UNIT_LANGUAGE (t1
),
1217 TRANSLATION_UNIT_LANGUAGE (t2
)) != 0)
1220 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
))
1221 if (!cl_target_option_eq (TREE_TARGET_OPTION (t1
), TREE_TARGET_OPTION (t2
)))
1224 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
1225 if (!cl_optimization_option_eq (TREE_OPTIMIZATION (t1
),
1226 TREE_OPTIMIZATION (t2
)))
1229 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1230 if (vec_safe_length (BINFO_BASE_ACCESSES (t1
))
1231 != vec_safe_length (BINFO_BASE_ACCESSES (t2
)))
1234 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1235 compare_values (CONSTRUCTOR_NELTS
);
1237 if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
1238 if (IDENTIFIER_LENGTH (t1
) != IDENTIFIER_LENGTH (t2
)
1239 || memcmp (IDENTIFIER_POINTER (t1
), IDENTIFIER_POINTER (t2
),
1240 IDENTIFIER_LENGTH (t1
)) != 0)
1243 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
1244 if (TREE_STRING_LENGTH (t1
) != TREE_STRING_LENGTH (t2
)
1245 || memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
1246 TREE_STRING_LENGTH (t1
)) != 0)
1249 if (code
== OMP_CLAUSE
)
1251 compare_values (OMP_CLAUSE_CODE
);
1252 switch (OMP_CLAUSE_CODE (t1
))
1254 case OMP_CLAUSE_DEFAULT
:
1255 compare_values (OMP_CLAUSE_DEFAULT_KIND
);
1257 case OMP_CLAUSE_SCHEDULE
:
1258 compare_values (OMP_CLAUSE_SCHEDULE_KIND
);
1260 case OMP_CLAUSE_DEPEND
:
1261 compare_values (OMP_CLAUSE_DEPEND_KIND
);
1263 case OMP_CLAUSE_MAP
:
1264 compare_values (OMP_CLAUSE_MAP_KIND
);
1266 case OMP_CLAUSE_PROC_BIND
:
1267 compare_values (OMP_CLAUSE_PROC_BIND_KIND
);
1269 case OMP_CLAUSE_REDUCTION
:
1270 compare_values (OMP_CLAUSE_REDUCTION_CODE
);
1271 compare_values (OMP_CLAUSE_REDUCTION_GIMPLE_INIT
);
1272 compare_values (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE
);
1279 #undef compare_values
1282 /* Compare pointer fields. */
1284 /* Recurse. Search & Replaced from DFS_write_tree_body.
1285 Folding the early checks into the compare_tree_edges recursion
1286 macro makes debugging way quicker as you are able to break on
1287 compare_tree_sccs_1 and simply finish until a call returns false
1288 to spot the SCC members with the difference. */
1289 #define compare_tree_edges(E1, E2) \
1291 tree t1_ = (E1), t2_ = (E2); \
1294 || !TREE_VISITED (t2_) \
1295 || (!TREE_ASM_WRITTEN (t2_) \
1296 && !compare_tree_sccs_1 (t1_, t2_, map)))) \
1298 /* Only non-NULL trees outside of the SCC may compare equal. */ \
1299 gcc_checking_assert (t1_ != t2_ || (!t2_ || !TREE_VISITED (t2_))); \
1302 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
1304 if (code
!= IDENTIFIER_NODE
)
1305 compare_tree_edges (TREE_TYPE (t1
), TREE_TYPE (t2
));
1308 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
1310 /* Note that the number of elements for EXPR has already been emitted
1311 in EXPR's header (see streamer_write_tree_header). */
1312 unsigned int count
= vector_cst_encoded_nelts (t1
);
1313 for (unsigned int i
= 0; i
< count
; ++i
)
1314 compare_tree_edges (VECTOR_CST_ENCODED_ELT (t1
, i
),
1315 VECTOR_CST_ENCODED_ELT (t2
, i
));
1318 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
1320 compare_tree_edges (TREE_REALPART (t1
), TREE_REALPART (t2
));
1321 compare_tree_edges (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
1324 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
1326 compare_tree_edges (DECL_NAME (t1
), DECL_NAME (t2
));
1327 /* ??? Global decls from different TUs have non-matching
1328 TRANSLATION_UNIT_DECLs. Only consider a small set of
1329 decls equivalent, we should not end up merging others. */
1330 if ((code
== TYPE_DECL
1331 || code
== NAMESPACE_DECL
1332 || code
== IMPORTED_DECL
1333 || code
== CONST_DECL
1334 || (VAR_OR_FUNCTION_DECL_P (t1
)
1335 && (TREE_PUBLIC (t1
) || DECL_EXTERNAL (t1
))))
1336 && DECL_FILE_SCOPE_P (t1
) && DECL_FILE_SCOPE_P (t2
))
1339 compare_tree_edges (DECL_CONTEXT (t1
), DECL_CONTEXT (t2
));
1342 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1344 compare_tree_edges (DECL_SIZE (t1
), DECL_SIZE (t2
));
1345 compare_tree_edges (DECL_SIZE_UNIT (t1
), DECL_SIZE_UNIT (t2
));
1346 compare_tree_edges (DECL_ATTRIBUTES (t1
), DECL_ATTRIBUTES (t2
));
1347 compare_tree_edges (DECL_ABSTRACT_ORIGIN (t1
), DECL_ABSTRACT_ORIGIN (t2
));
1348 if ((code
== VAR_DECL
1349 || code
== PARM_DECL
)
1350 && DECL_HAS_VALUE_EXPR_P (t1
))
1351 compare_tree_edges (DECL_VALUE_EXPR (t1
), DECL_VALUE_EXPR (t2
));
1352 if (code
== VAR_DECL
1353 && DECL_HAS_DEBUG_EXPR_P (t1
))
1354 compare_tree_edges (DECL_DEBUG_EXPR (t1
), DECL_DEBUG_EXPR (t2
));
1355 /* LTO specific edges. */
1356 if (code
!= FUNCTION_DECL
1357 && code
!= TRANSLATION_UNIT_DECL
)
1358 compare_tree_edges (DECL_INITIAL (t1
), DECL_INITIAL (t2
));
1361 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
1363 if (code
== FUNCTION_DECL
)
1366 for (a1
= DECL_ARGUMENTS (t1
), a2
= DECL_ARGUMENTS (t2
);
1368 a1
= TREE_CHAIN (a1
), a2
= TREE_CHAIN (a2
))
1369 compare_tree_edges (a1
, a2
);
1370 compare_tree_edges (DECL_RESULT (t1
), DECL_RESULT (t2
));
1372 else if (code
== TYPE_DECL
)
1373 compare_tree_edges (DECL_ORIGINAL_TYPE (t1
), DECL_ORIGINAL_TYPE (t2
));
1376 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1378 /* Make sure we don't inadvertently set the assembler name. */
1379 if (DECL_ASSEMBLER_NAME_SET_P (t1
))
1380 compare_tree_edges (DECL_ASSEMBLER_NAME (t1
),
1381 DECL_ASSEMBLER_NAME (t2
));
1384 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
1386 compare_tree_edges (DECL_FIELD_OFFSET (t1
), DECL_FIELD_OFFSET (t2
));
1387 compare_tree_edges (DECL_BIT_FIELD_TYPE (t1
), DECL_BIT_FIELD_TYPE (t2
));
1388 compare_tree_edges (DECL_BIT_FIELD_REPRESENTATIVE (t1
),
1389 DECL_BIT_FIELD_REPRESENTATIVE (t2
));
1390 compare_tree_edges (DECL_FIELD_BIT_OFFSET (t1
),
1391 DECL_FIELD_BIT_OFFSET (t2
));
1392 compare_tree_edges (DECL_FCONTEXT (t1
), DECL_FCONTEXT (t2
));
1395 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1397 compare_tree_edges (DECL_FUNCTION_PERSONALITY (t1
),
1398 DECL_FUNCTION_PERSONALITY (t2
));
1399 compare_tree_edges (DECL_VINDEX (t1
), DECL_VINDEX (t2
));
1400 compare_tree_edges (DECL_FUNCTION_SPECIFIC_TARGET (t1
),
1401 DECL_FUNCTION_SPECIFIC_TARGET (t2
));
1402 compare_tree_edges (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t1
),
1403 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t2
));
1406 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
1408 compare_tree_edges (TYPE_SIZE (t1
), TYPE_SIZE (t2
));
1409 compare_tree_edges (TYPE_SIZE_UNIT (t1
), TYPE_SIZE_UNIT (t2
));
1410 compare_tree_edges (TYPE_ATTRIBUTES (t1
), TYPE_ATTRIBUTES (t2
));
1411 compare_tree_edges (TYPE_NAME (t1
), TYPE_NAME (t2
));
1412 /* Do not compare TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
1413 reconstructed during fixup. */
1414 /* Do not compare TYPE_NEXT_VARIANT, we reconstruct the variant lists
1416 compare_tree_edges (TYPE_MAIN_VARIANT (t1
), TYPE_MAIN_VARIANT (t2
));
1417 /* ??? Global types from different TUs have non-matching
1418 TRANSLATION_UNIT_DECLs. Still merge them if they are otherwise
1420 if (TYPE_FILE_SCOPE_P (t1
) && TYPE_FILE_SCOPE_P (t2
))
1423 compare_tree_edges (TYPE_CONTEXT (t1
), TYPE_CONTEXT (t2
));
1424 /* TYPE_CANONICAL is re-computed during type merging, so do not
1426 compare_tree_edges (TYPE_STUB_DECL (t1
), TYPE_STUB_DECL (t2
));
1429 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
1431 if (code
== ENUMERAL_TYPE
)
1432 compare_tree_edges (TYPE_VALUES (t1
), TYPE_VALUES (t2
));
1433 else if (code
== ARRAY_TYPE
)
1434 compare_tree_edges (TYPE_DOMAIN (t1
), TYPE_DOMAIN (t2
));
1435 else if (RECORD_OR_UNION_TYPE_P (t1
))
1438 for (f1
= TYPE_FIELDS (t1
), f2
= TYPE_FIELDS (t2
);
1440 f1
= TREE_CHAIN (f1
), f2
= TREE_CHAIN (f2
))
1441 compare_tree_edges (f1
, f2
);
1443 else if (code
== FUNCTION_TYPE
1444 || code
== METHOD_TYPE
)
1445 compare_tree_edges (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
));
1447 if (!POINTER_TYPE_P (t1
))
1448 compare_tree_edges (TYPE_MIN_VALUE_RAW (t1
), TYPE_MIN_VALUE_RAW (t2
));
1449 compare_tree_edges (TYPE_MAX_VALUE_RAW (t1
), TYPE_MAX_VALUE_RAW (t2
));
1452 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
1454 compare_tree_edges (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
));
1455 compare_tree_edges (TREE_VALUE (t1
), TREE_VALUE (t2
));
1456 compare_tree_edges (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
1459 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1460 for (int i
= 0; i
< TREE_VEC_LENGTH (t1
); i
++)
1461 compare_tree_edges (TREE_VEC_ELT (t1
, i
), TREE_VEC_ELT (t2
, i
));
1463 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
1465 for (int i
= 0; i
< TREE_OPERAND_LENGTH (t1
); i
++)
1466 compare_tree_edges (TREE_OPERAND (t1
, i
),
1467 TREE_OPERAND (t2
, i
));
1469 /* BLOCKs are function local and we don't merge anything there. */
1470 if (TREE_BLOCK (t1
) || TREE_BLOCK (t2
))
1474 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1478 /* Lengths have already been compared above. */
1479 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (t1
), i
, t
)
1480 compare_tree_edges (t
, BINFO_BASE_BINFO (t2
, i
));
1481 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (t1
), i
, t
)
1482 compare_tree_edges (t
, BINFO_BASE_ACCESS (t2
, i
));
1483 compare_tree_edges (BINFO_OFFSET (t1
), BINFO_OFFSET (t2
));
1484 compare_tree_edges (BINFO_VTABLE (t1
), BINFO_VTABLE (t2
));
1485 compare_tree_edges (BINFO_VPTR_FIELD (t1
), BINFO_VPTR_FIELD (t2
));
1486 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
1487 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
1490 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1494 /* Lengths have already been compared above. */
1495 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, index
, value
)
1497 compare_tree_edges (index
, CONSTRUCTOR_ELT (t2
, i
)->index
);
1498 compare_tree_edges (value
, CONSTRUCTOR_ELT (t2
, i
)->value
);
1502 if (code
== OMP_CLAUSE
)
1506 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (t1
)]; i
++)
1507 compare_tree_edges (OMP_CLAUSE_OPERAND (t1
, i
),
1508 OMP_CLAUSE_OPERAND (t2
, i
));
1509 compare_tree_edges (OMP_CLAUSE_CHAIN (t1
), OMP_CLAUSE_CHAIN (t2
));
1512 #undef compare_tree_edges
1517 /* Compare the tree scc SCC to the prevailing candidate PSCC, filling
1518 out MAP if they are equal. */
1521 compare_tree_sccs (tree_scc
*pscc
, tree_scc
*scc
,
1524 /* Assume SCC entry hashes are sorted after their cardinality. Which
1525 means we can simply take the first n-tuple of equal hashes
1526 (which is recorded as entry_len) and do n SCC entry candidate
1528 for (unsigned i
= 0; i
< pscc
->entry_len
; ++i
)
1531 num_scc_compare_collisions
++;
1532 if (compare_tree_sccs_1 (pscc
->entries
[0], scc
->entries
[i
], &mapp
))
1534 /* Equal - no need to reset TREE_VISITED or TREE_ASM_WRITTEN
1535 on the scc as all trees will be freed. */
1538 /* Reset TREE_ASM_WRITTEN on scc for the next compare or in case
1539 the SCC prevails. */
1540 for (unsigned j
= 0; j
< scc
->len
; ++j
)
1541 TREE_ASM_WRITTEN (scc
->entries
[j
]) = 0;
1547 /* QSort sort function to sort a map of two pointers after the 2nd
1551 cmp_tree (const void *p1_
, const void *p2_
)
1553 tree
*p1
= (tree
*)(const_cast<void *>(p1_
));
1554 tree
*p2
= (tree
*)(const_cast<void *>(p2_
));
1557 return ((uintptr_t)p1
[1] < (uintptr_t)p2
[1]) ? -1 : 1;
1560 /* Try to unify the SCC with nodes FROM to FROM + LEN in CACHE and
1561 hash value SCC_HASH with an already recorded SCC. Return true if
1562 that was successful, otherwise return false. */
1565 unify_scc (struct data_in
*data_in
, unsigned from
,
1566 unsigned len
, unsigned scc_entry_len
, hashval_t scc_hash
)
1568 bool unified_p
= false;
1569 struct streamer_tree_cache_d
*cache
= data_in
->reader_cache
;
1571 = (tree_scc
*) alloca (sizeof (tree_scc
) + (len
- 1) * sizeof (tree
));
1573 scc
->hash
= scc_hash
;
1575 scc
->entry_len
= scc_entry_len
;
1576 for (unsigned i
= 0; i
< len
; ++i
)
1578 tree t
= streamer_tree_cache_get_tree (cache
, from
+ i
);
1579 scc
->entries
[i
] = t
;
1580 /* Do not merge SCCs with local entities inside them. Also do
1581 not merge TRANSLATION_UNIT_DECLs. */
1582 if (TREE_CODE (t
) == TRANSLATION_UNIT_DECL
1583 || (VAR_OR_FUNCTION_DECL_P (t
)
1584 && !(TREE_PUBLIC (t
) || DECL_EXTERNAL (t
)))
1585 || TREE_CODE (t
) == LABEL_DECL
)
1587 /* Avoid doing any work for these cases and do not worry to
1588 record the SCCs for further merging. */
1593 /* Look for the list of candidate SCCs to compare against. */
1595 slot
= tree_scc_hash
->find_slot_with_hash (scc
, scc_hash
, INSERT
);
1598 /* Try unifying against each candidate. */
1601 /* Set TREE_VISITED on the scc so we can easily identify tree nodes
1602 outside of the scc when following tree edges. Make sure
1603 that TREE_ASM_WRITTEN is unset so we can use it as 2nd bit
1604 to track whether we visited the SCC member during the compare.
1605 We cannot use TREE_VISITED on the pscc members as the extended
1606 scc and pscc can overlap. */
1607 for (unsigned i
= 0; i
< scc
->len
; ++i
)
1609 TREE_VISITED (scc
->entries
[i
]) = 1;
1610 gcc_checking_assert (!TREE_ASM_WRITTEN (scc
->entries
[i
]));
1613 tree
*map
= XALLOCAVEC (tree
, 2 * len
);
1614 for (tree_scc
*pscc
= *slot
; pscc
; pscc
= pscc
->next
)
1616 if (!compare_tree_sccs (pscc
, scc
, map
))
1619 /* Found an equal SCC. */
1621 num_scc_compare_collisions
--;
1623 total_scc_size_merged
+= len
;
1626 for (unsigned i
= 0; i
< len
; ++i
)
1628 tree t
= map
[2*i
+1];
1629 enum tree_code code
= TREE_CODE (t
);
1630 /* IDENTIFIER_NODEs should be singletons and are merged by the
1631 streamer. The others should be singletons, too, and we
1632 should not merge them in any way. */
1633 gcc_assert (code
!= TRANSLATION_UNIT_DECL
1634 && code
!= IDENTIFIER_NODE
);
1637 /* Fixup the streamer cache with the prevailing nodes according
1638 to the tree node mapping computed by compare_tree_sccs. */
1641 lto_maybe_register_decl (data_in
, pscc
->entries
[0], from
);
1642 streamer_tree_cache_replace_tree (cache
, pscc
->entries
[0], from
);
1646 tree
*map2
= XALLOCAVEC (tree
, 2 * len
);
1647 for (unsigned i
= 0; i
< len
; ++i
)
1649 map2
[i
*2] = (tree
)(uintptr_t)(from
+ i
);
1650 map2
[i
*2+1] = scc
->entries
[i
];
1652 qsort (map2
, len
, 2 * sizeof (tree
), cmp_tree
);
1653 qsort (map
, len
, 2 * sizeof (tree
), cmp_tree
);
1654 for (unsigned i
= 0; i
< len
; ++i
)
1656 lto_maybe_register_decl (data_in
, map
[2*i
],
1657 (uintptr_t)map2
[2*i
]);
1658 streamer_tree_cache_replace_tree (cache
, map
[2*i
],
1659 (uintptr_t)map2
[2*i
]);
1663 /* Free the tree nodes from the read SCC. */
1664 data_in
->location_cache
.revert_location_cache ();
1665 for (unsigned i
= 0; i
< len
; ++i
)
1667 if (TYPE_P (scc
->entries
[i
]))
1669 free_node (scc
->entries
[i
]);
1672 /* Drop DIE references. */
1673 dref_queue
.truncate (0);
1678 /* Reset TREE_VISITED if we didn't unify the SCC with another. */
1680 for (unsigned i
= 0; i
< scc
->len
; ++i
)
1681 TREE_VISITED (scc
->entries
[i
]) = 0;
1684 /* If we didn't unify it to any candidate duplicate the relevant
1685 pieces to permanent storage and link it into the chain. */
1689 = XOBNEWVAR (&tree_scc_hash_obstack
, tree_scc
, sizeof (tree_scc
));
1690 memcpy (pscc
, scc
, sizeof (tree_scc
));
1691 pscc
->next
= (*slot
);
1698 /* Compare types based on source file location. */
1701 cmp_type_location (const void *p1_
, const void *p2_
)
1703 tree
*p1
= (tree
*)(const_cast<void *>(p1_
));
1704 tree
*p2
= (tree
*)(const_cast<void *>(p2_
));
1708 tree tname1
= TYPE_NAME (*p1
);
1709 tree tname2
= TYPE_NAME (*p2
);
1710 expanded_location xloc1
= expand_location (DECL_SOURCE_LOCATION (tname1
));
1711 expanded_location xloc2
= expand_location (DECL_SOURCE_LOCATION (tname2
));
1713 const char *f1
= lbasename (xloc1
.file
);
1714 const char *f2
= lbasename (xloc2
.file
);
1715 int r
= strcmp (f1
, f2
);
1718 int l1
= xloc1
.line
;
1719 int l2
= xloc2
.line
;
1722 return xloc1
.column
- xloc2
.column
;
1728 /* Read all the symbols from buffer DATA, using descriptors in DECL_DATA.
1729 RESOLUTIONS is the set of symbols picked by the linker (read from the
1730 resolution file when the linker plugin is being used). */
1733 lto_read_decls (struct lto_file_decl_data
*decl_data
, const void *data
,
1734 vec
<ld_plugin_symbol_resolution_t
> resolutions
)
1736 const struct lto_decl_header
*header
= (const struct lto_decl_header
*) data
;
1737 const int decl_offset
= sizeof (struct lto_decl_header
);
1738 const int main_offset
= decl_offset
+ header
->decl_state_size
;
1739 const int string_offset
= main_offset
+ header
->main_size
;
1740 struct data_in
*data_in
;
1742 const uint32_t *data_ptr
, *data_end
;
1743 uint32_t num_decl_states
;
1744 auto_vec
<tree
> odr_types
;
1746 lto_input_block
ib_main ((const char *) data
+ main_offset
,
1747 header
->main_size
, decl_data
->mode_table
);
1749 data_in
= lto_data_in_create (decl_data
, (const char *) data
+ string_offset
,
1750 header
->string_size
, resolutions
);
1752 /* We do not uniquify the pre-loaded cache entries, those are middle-end
1753 internal types that should not be merged. */
1755 /* Read the global declarations and types. */
1756 while (ib_main
.p
< ib_main
.len
)
1759 unsigned from
= data_in
->reader_cache
->nodes
.length ();
1760 /* Read and uniquify SCCs as in the input stream. */
1761 enum LTO_tags tag
= streamer_read_record_start (&ib_main
);
1762 if (tag
== LTO_tree_scc
)
1765 unsigned scc_entry_len
;
1766 hashval_t scc_hash
= lto_input_scc (&ib_main
, data_in
, &len_
,
1768 unsigned len
= data_in
->reader_cache
->nodes
.length () - from
;
1769 gcc_assert (len
== len_
);
1771 total_scc_size
+= len
;
1774 /* We have the special case of size-1 SCCs that are pre-merged
1775 by means of identifier and string sharing for example.
1776 ??? Maybe we should avoid streaming those as SCCs. */
1777 tree first
= streamer_tree_cache_get_tree (data_in
->reader_cache
,
1780 && (TREE_CODE (first
) == IDENTIFIER_NODE
1781 || TREE_CODE (first
) == INTEGER_CST
))
1784 /* Try to unify the SCC with already existing ones. */
1786 && unify_scc (data_in
, from
,
1787 len
, scc_entry_len
, scc_hash
))
1790 /* Tree merging failed, mark entries in location cache as
1792 data_in
->location_cache
.accept_location_cache ();
1794 bool seen_type
= false;
1795 for (unsigned i
= 0; i
< len
; ++i
)
1797 tree t
= streamer_tree_cache_get_tree (data_in
->reader_cache
,
1799 /* Reconstruct the type variant and pointer-to/reference-to
1804 num_prevailing_types
++;
1805 lto_fixup_prevailing_type (t
);
1807 /* Compute the canonical type of all types.
1808 Because SCC components are streamed in random (hash) order
1809 we may have encountered the type before while registering
1810 type canonical of a derived type in the same SCC. */
1811 if (!TYPE_CANONICAL (t
))
1812 gimple_register_canonical_type (t
);
1814 odr_types
.safe_push (t
);
1816 /* Link shared INTEGER_CSTs into TYPE_CACHED_VALUEs of its
1817 type which is also member of this SCC. */
1818 if (TREE_CODE (t
) == INTEGER_CST
1819 && !TREE_OVERFLOW (t
))
1820 cache_integer_cst (t
);
1823 lto_maybe_register_decl (data_in
, t
, from
+ i
);
1824 /* Scan the tree for references to global functions or
1825 variables and record those for later fixup. */
1826 if (mentions_vars_p (t
))
1827 vec_safe_push (tree_with_vars
, t
);
1831 /* Register DECLs with the debuginfo machinery. */
1832 while (!dref_queue
.is_empty ())
1834 dref_entry e
= dref_queue
.pop ();
1835 debug_hooks
->register_external_die (e
.decl
, e
.sym
, e
.off
);
1839 num_type_scc_trees
+= len
;
1843 /* Pickle stray references. */
1844 t
= lto_input_tree_1 (&ib_main
, data_in
, tag
, 0);
1845 gcc_assert (t
&& data_in
->reader_cache
->nodes
.length () == from
);
1848 data_in
->location_cache
.apply_location_cache ();
1850 /* Read in lto_in_decl_state objects. */
1851 data_ptr
= (const uint32_t *) ((const char*) data
+ decl_offset
);
1853 (const uint32_t *) ((const char*) data_ptr
+ header
->decl_state_size
);
1854 num_decl_states
= *data_ptr
++;
1856 gcc_assert (num_decl_states
> 0);
1857 decl_data
->global_decl_state
= lto_new_in_decl_state ();
1858 data_ptr
= lto_read_in_decl_state (data_in
, data_ptr
,
1859 decl_data
->global_decl_state
);
1861 /* Read in per-function decl states and enter them in hash table. */
1862 decl_data
->function_decl_states
=
1863 hash_table
<decl_state_hasher
>::create_ggc (37);
1865 for (i
= 1; i
< num_decl_states
; i
++)
1867 struct lto_in_decl_state
*state
= lto_new_in_decl_state ();
1869 data_ptr
= lto_read_in_decl_state (data_in
, data_ptr
, state
);
1870 lto_in_decl_state
**slot
1871 = decl_data
->function_decl_states
->find_slot (state
, INSERT
);
1872 gcc_assert (*slot
== NULL
);
1876 /* Sort types for the file before registering in ODR machinery. */
1877 if (lto_location_cache::current_cache
)
1878 lto_location_cache::current_cache
->apply_location_cache ();
1879 odr_types
.qsort (cmp_type_location
);
1881 /* Register ODR types. */
1882 for (unsigned i
= 0; i
< odr_types
.length (); i
++)
1883 register_odr_type (odr_types
[i
]);
1885 if (data_ptr
!= data_end
)
1886 internal_error ("bytecode stream: garbage at the end of symbols section");
1888 /* Set the current decl state to be the global state. */
1889 decl_data
->current_decl_state
= decl_data
->global_decl_state
;
1891 lto_data_in_delete (data_in
);
1894 /* Custom version of strtoll, which is not portable. */
1897 lto_parse_hex (const char *p
)
1901 for (; *p
!= '\0'; ++p
)
1906 if (c
>= '0' && c
<= '9')
1908 else if (c
>= 'a' && c
<= 'f')
1909 part
= c
- 'a' + 10;
1910 else if (c
>= 'A' && c
<= 'F')
1911 part
= c
- 'A' + 10;
1913 internal_error ("could not parse hex number");
1920 /* Read resolution for file named FILE_NAME. The resolution is read from
1924 lto_resolution_read (splay_tree file_ids
, FILE *resolution
, lto_file
*file
)
1926 /* We require that objects in the resolution file are in the same
1927 order as the lto1 command line. */
1928 unsigned int name_len
;
1930 unsigned int num_symbols
;
1932 struct lto_file_decl_data
*file_data
;
1933 splay_tree_node nd
= NULL
;
1938 name_len
= strlen (file
->filename
);
1939 obj_name
= XNEWVEC (char, name_len
+ 1);
1940 fscanf (resolution
, " "); /* Read white space. */
1942 fread (obj_name
, sizeof (char), name_len
, resolution
);
1943 obj_name
[name_len
] = '\0';
1944 if (filename_cmp (obj_name
, file
->filename
) != 0)
1945 internal_error ("unexpected file name %s in linker resolution file. "
1946 "Expected %s", obj_name
, file
->filename
);
1947 if (file
->offset
!= 0)
1952 t
= fscanf (resolution
, "@0x%16s", offset_p
);
1954 internal_error ("could not parse file offset");
1955 offset
= lto_parse_hex (offset_p
);
1956 if (offset
!= file
->offset
)
1957 internal_error ("unexpected offset");
1962 fscanf (resolution
, "%u", &num_symbols
);
1964 for (i
= 0; i
< num_symbols
; i
++)
1968 unsigned HOST_WIDE_INT id
;
1970 enum ld_plugin_symbol_resolution r
= (enum ld_plugin_symbol_resolution
) 0;
1972 unsigned int lto_resolution_str_len
=
1973 sizeof (lto_resolution_str
) / sizeof (char *);
1976 t
= fscanf (resolution
, "%u " HOST_WIDE_INT_PRINT_HEX_PURE
" %26s %*[^\n]\n",
1977 &index
, &id
, r_str
);
1979 internal_error ("invalid line in the resolution file");
1981 for (j
= 0; j
< lto_resolution_str_len
; j
++)
1983 if (strcmp (lto_resolution_str
[j
], r_str
) == 0)
1985 r
= (enum ld_plugin_symbol_resolution
) j
;
1989 if (j
== lto_resolution_str_len
)
1990 internal_error ("invalid resolution in the resolution file");
1992 if (!(nd
&& lto_splay_tree_id_equal_p (nd
->key
, id
)))
1994 nd
= lto_splay_tree_lookup (file_ids
, id
);
1996 internal_error ("resolution sub id %wx not in object file", id
);
1999 file_data
= (struct lto_file_decl_data
*)nd
->value
;
2000 /* The indexes are very sparse. To save memory save them in a compact
2001 format that is only unpacked later when the subfile is processed. */
2004 file_data
->respairs
.safe_push (rp
);
2005 if (file_data
->max_index
< index
)
2006 file_data
->max_index
= index
;
2010 /* List of file_decl_datas */
2011 struct file_data_list
2013 struct lto_file_decl_data
*first
, *last
;
2016 /* Is the name for a id'ed LTO section? */
2019 lto_section_with_id (const char *name
, unsigned HOST_WIDE_INT
*id
)
2023 if (strncmp (name
, section_name_prefix
, strlen (section_name_prefix
)))
2025 s
= strrchr (name
, '.');
2028 /* If the section is not suffixed with an ID return. */
2029 if ((size_t)(s
- name
) == strlen (section_name_prefix
))
2031 return sscanf (s
, "." HOST_WIDE_INT_PRINT_HEX_PURE
, id
) == 1;
2034 /* Create file_data of each sub file id */
2037 create_subid_section_table (struct lto_section_slot
*ls
, splay_tree file_ids
,
2038 struct file_data_list
*list
)
2040 struct lto_section_slot s_slot
, *new_slot
;
2041 unsigned HOST_WIDE_INT id
;
2045 struct lto_file_decl_data
*file_data
;
2047 if (!lto_section_with_id (ls
->name
, &id
))
2050 /* Find hash table of sub module id */
2051 nd
= lto_splay_tree_lookup (file_ids
, id
);
2054 file_data
= (struct lto_file_decl_data
*)nd
->value
;
2058 file_data
= ggc_alloc
<lto_file_decl_data
> ();
2059 memset(file_data
, 0, sizeof (struct lto_file_decl_data
));
2061 file_data
->section_hash_table
= lto_obj_create_section_hash_table ();
2062 lto_splay_tree_insert (file_ids
, id
, file_data
);
2064 /* Maintain list in linker order */
2066 list
->first
= file_data
;
2068 list
->last
->next
= file_data
;
2069 list
->last
= file_data
;
2072 /* Copy section into sub module hash table */
2073 new_name
= XDUPVEC (char, ls
->name
, strlen (ls
->name
) + 1);
2074 s_slot
.name
= new_name
;
2075 hash_slot
= htab_find_slot (file_data
->section_hash_table
, &s_slot
, INSERT
);
2076 gcc_assert (*hash_slot
== NULL
);
2078 new_slot
= XDUP (struct lto_section_slot
, ls
);
2079 new_slot
->name
= new_name
;
2080 *hash_slot
= new_slot
;
2084 /* Read declarations and other initializations for a FILE_DATA. */
2087 lto_file_finalize (struct lto_file_decl_data
*file_data
, lto_file
*file
)
2091 vec
<ld_plugin_symbol_resolution_t
>
2092 resolutions
= vNULL
;
2096 /* Create vector for fast access of resolution. We do this lazily
2098 resolutions
.safe_grow_cleared (file_data
->max_index
+ 1);
2099 for (i
= 0; file_data
->respairs
.iterate (i
, &rp
); i
++)
2100 resolutions
[rp
->index
] = rp
->res
;
2101 file_data
->respairs
.release ();
2103 file_data
->renaming_hash_table
= lto_create_renaming_table ();
2104 file_data
->file_name
= file
->filename
;
2105 #ifdef ACCEL_COMPILER
2106 lto_input_mode_table (file_data
);
2108 file_data
->mode_table
= lto_mode_identity_table
;
2110 data
= lto_get_section_data (file_data
, LTO_section_decls
, NULL
, &len
);
2113 internal_error ("cannot read LTO decls from %s", file_data
->file_name
);
2116 /* Frees resolutions */
2117 lto_read_decls (file_data
, data
, resolutions
);
2118 lto_free_section_data (file_data
, LTO_section_decls
, NULL
, data
, len
);
2121 /* Finalize FILE_DATA in FILE and increase COUNT. */
2124 lto_create_files_from_ids (lto_file
*file
, struct lto_file_decl_data
*file_data
,
2127 lto_file_finalize (file_data
, file
);
2128 if (symtab
->dump_file
)
2129 fprintf (symtab
->dump_file
,
2130 "Creating file %s with sub id " HOST_WIDE_INT_PRINT_HEX
"\n",
2131 file_data
->file_name
, file_data
->id
);
2136 /* Generate a TREE representation for all types and external decls
2139 Read all of the globals out of the file. Then read the cgraph
2140 and process the .o index into the cgraph nodes so that it can open
2141 the .o file to load the functions and ipa information. */
2143 static struct lto_file_decl_data
*
2144 lto_file_read (lto_file
*file
, FILE *resolution_file
, int *count
)
2146 struct lto_file_decl_data
*file_data
= NULL
;
2147 splay_tree file_ids
;
2148 htab_t section_hash_table
;
2149 struct lto_section_slot
*section
;
2150 struct file_data_list file_list
;
2151 struct lto_section_list section_list
;
2153 memset (§ion_list
, 0, sizeof (struct lto_section_list
));
2154 section_hash_table
= lto_obj_build_section_table (file
, §ion_list
);
2156 /* Find all sub modules in the object and put their sections into new hash
2157 tables in a splay tree. */
2158 file_ids
= lto_splay_tree_new ();
2159 memset (&file_list
, 0, sizeof (struct file_data_list
));
2160 for (section
= section_list
.first
; section
!= NULL
; section
= section
->next
)
2161 create_subid_section_table (section
, file_ids
, &file_list
);
2163 /* Add resolutions to file ids */
2164 lto_resolution_read (file_ids
, resolution_file
, file
);
2166 /* Finalize each lto file for each submodule in the merged object */
2167 for (file_data
= file_list
.first
; file_data
!= NULL
; file_data
= file_data
->next
)
2168 lto_create_files_from_ids (file
, file_data
, count
);
2170 splay_tree_delete (file_ids
);
2171 htab_delete (section_hash_table
);
2173 return file_list
.first
;
2176 #if HAVE_MMAP_FILE && HAVE_SYSCONF && defined _SC_PAGE_SIZE
2177 #define LTO_MMAP_IO 1
2181 /* Page size of machine is used for mmap and munmap calls. */
2182 static size_t page_mask
;
2185 /* Get the section data of length LEN from FILENAME starting at
2186 OFFSET. The data segment must be freed by the caller when the
2187 caller is finished. Returns NULL if all was not well. */
2190 lto_read_section_data (struct lto_file_decl_data
*file_data
,
2191 intptr_t offset
, size_t len
)
2195 static char *fd_name
;
2197 intptr_t computed_len
;
2198 intptr_t computed_offset
;
2202 /* Keep a single-entry file-descriptor cache. The last file we
2203 touched will get closed at exit.
2204 ??? Eventually we want to add a more sophisticated larger cache
2205 or rather fix function body streaming to not stream them in
2206 practically random order. */
2208 && filename_cmp (fd_name
, file_data
->file_name
) != 0)
2216 fd
= open (file_data
->file_name
, O_RDONLY
|O_BINARY
);
2219 fatal_error (input_location
, "Cannot open %s", file_data
->file_name
);
2222 fd_name
= xstrdup (file_data
->file_name
);
2228 size_t page_size
= sysconf (_SC_PAGE_SIZE
);
2229 page_mask
= ~(page_size
- 1);
2232 computed_offset
= offset
& page_mask
;
2233 diff
= offset
- computed_offset
;
2234 computed_len
= len
+ diff
;
2236 result
= (char *) mmap (NULL
, computed_len
, PROT_READ
, MAP_PRIVATE
,
2237 fd
, computed_offset
);
2238 if (result
== MAP_FAILED
)
2240 fatal_error (input_location
, "Cannot map %s", file_data
->file_name
);
2244 return result
+ diff
;
2246 result
= (char *) xmalloc (len
);
2247 if (lseek (fd
, offset
, SEEK_SET
) != offset
2248 || read (fd
, result
, len
) != (ssize_t
) len
)
2251 fatal_error (input_location
, "Cannot read %s", file_data
->file_name
);
2255 /* Native windows doesn't supports delayed unlink on opened file. So
2256 we close file here again. This produces higher I/O load, but at least
2257 it prevents to have dangling file handles preventing unlink. */
2268 /* Get the section data from FILE_DATA of SECTION_TYPE with NAME.
2269 NAME will be NULL unless the section type is for a function
2273 get_section_data (struct lto_file_decl_data
*file_data
,
2274 enum lto_section_type section_type
,
2278 htab_t section_hash_table
= file_data
->section_hash_table
;
2279 struct lto_section_slot
*f_slot
;
2280 struct lto_section_slot s_slot
;
2281 const char *section_name
= lto_get_section_name (section_type
, name
, file_data
);
2285 s_slot
.name
= section_name
;
2286 f_slot
= (struct lto_section_slot
*) htab_find (section_hash_table
, &s_slot
);
2289 data
= lto_read_section_data (file_data
, f_slot
->start
, f_slot
->len
);
2293 free (CONST_CAST (char *, section_name
));
2298 /* Free the section data from FILE_DATA of SECTION_TYPE with NAME that
2299 starts at OFFSET and has LEN bytes. */
2302 free_section_data (struct lto_file_decl_data
*file_data ATTRIBUTE_UNUSED
,
2303 enum lto_section_type section_type ATTRIBUTE_UNUSED
,
2304 const char *name ATTRIBUTE_UNUSED
,
2305 const char *offset
, size_t len ATTRIBUTE_UNUSED
)
2308 intptr_t computed_len
;
2309 intptr_t computed_offset
;
2314 computed_offset
= ((intptr_t) offset
) & page_mask
;
2315 diff
= (intptr_t) offset
- computed_offset
;
2316 computed_len
= len
+ diff
;
2318 munmap ((caddr_t
) computed_offset
, computed_len
);
2320 free (CONST_CAST(char *, offset
));
2324 static lto_file
*current_lto_file
;
2326 /* Actually stream out ENCODER into TEMP_FILENAME. */
2329 do_stream_out (char *temp_filename
, lto_symtab_encoder_t encoder
, int part
)
2331 lto_file
*file
= lto_obj_file_open (temp_filename
, true);
2333 fatal_error (input_location
, "lto_obj_file_open() failed");
2334 lto_set_current_out_file (file
);
2336 gcc_assert (!dump_file
);
2337 streamer_dump_file
= dump_begin (TDI_lto_stream_out
, NULL
, part
);
2338 ipa_write_optimization_summaries (encoder
);
2340 free (CONST_CAST (char *, file
->filename
));
2342 lto_set_current_out_file (NULL
);
2343 lto_obj_file_close (file
);
2345 if (streamer_dump_file
)
2347 dump_end (TDI_lto_stream_out
, streamer_dump_file
);
2348 streamer_dump_file
= NULL
;
2352 /* Wait for forked process and signal errors. */
2353 #ifdef HAVE_WORKING_FORK
2361 #define WCONTINUED 0
2363 int w
= waitpid (0, &status
, WUNTRACED
| WCONTINUED
);
2365 fatal_error (input_location
, "waitpid failed");
2367 if (WIFEXITED (status
) && WEXITSTATUS (status
))
2368 fatal_error (input_location
, "streaming subprocess failed");
2369 else if (WIFSIGNALED (status
))
2370 fatal_error (input_location
,
2371 "streaming subprocess was killed by signal");
2373 while (!WIFEXITED (status
) && !WIFSIGNALED (status
));
2377 /* Stream out ENCODER into TEMP_FILENAME
2378 Fork if that seems to help. */
2381 stream_out (char *temp_filename
, lto_symtab_encoder_t encoder
,
2382 bool ARG_UNUSED (last
), int part
)
2384 #ifdef HAVE_WORKING_FORK
2387 if (lto_parallelism
<= 1)
2389 do_stream_out (temp_filename
, encoder
, part
);
2393 /* Do not run more than LTO_PARALLELISM streamings
2394 FIXME: we ignore limits on jobserver. */
2395 if (lto_parallelism
> 0 && nruns
>= lto_parallelism
)
2400 /* If this is not the last parallel partition, execute new
2401 streaming process. */
2404 pid_t cpid
= fork ();
2408 setproctitle ("lto1-wpa-streaming");
2409 do_stream_out (temp_filename
, encoder
, part
);
2412 /* Fork failed; lets do the job ourseleves. */
2413 else if (cpid
== -1)
2414 do_stream_out (temp_filename
, encoder
, part
);
2418 /* Last partition; stream it and wait for all children to die. */
2422 do_stream_out (temp_filename
, encoder
, part
);
2423 for (i
= 0; i
< nruns
; i
++)
2426 asm_nodes_output
= true;
2428 do_stream_out (temp_filename
, encoder
, part
);
2432 /* Write all output files in WPA mode and the file with the list of
2436 lto_wpa_write_files (void)
2439 ltrans_partition part
;
2440 FILE *ltrans_output_list_stream
;
2441 char *temp_filename
;
2442 auto_vec
<char *>temp_filenames
;
2443 auto_vec
<int>temp_priority
;
2446 /* Open the LTRANS output list. */
2447 if (!ltrans_output_list
)
2448 fatal_error (input_location
, "no LTRANS output list filename provided");
2450 timevar_push (TV_WHOPR_WPA
);
2452 FOR_EACH_VEC_ELT (ltrans_partitions
, i
, part
)
2453 lto_stats
.num_output_symtab_nodes
+= lto_symtab_encoder_size (part
->encoder
);
2455 timevar_pop (TV_WHOPR_WPA
);
2457 timevar_push (TV_WHOPR_WPA_IO
);
2459 /* Generate a prefix for the LTRANS unit files. */
2460 blen
= strlen (ltrans_output_list
);
2461 temp_filename
= (char *) xmalloc (blen
+ sizeof ("2147483648.o"));
2462 strcpy (temp_filename
, ltrans_output_list
);
2463 if (blen
> sizeof (".out")
2464 && strcmp (temp_filename
+ blen
- sizeof (".out") + 1,
2466 temp_filename
[blen
- sizeof (".out") + 1] = '\0';
2467 blen
= strlen (temp_filename
);
2469 n_sets
= ltrans_partitions
.length ();
2471 for (i
= 0; i
< n_sets
; i
++)
2473 ltrans_partition part
= ltrans_partitions
[i
];
2475 /* Write all the nodes in SET. */
2476 sprintf (temp_filename
+ blen
, "%u.o", i
);
2479 fprintf (stderr
, " %s (%s %i insns)", temp_filename
, part
->name
, part
->insns
);
2480 if (symtab
->dump_file
)
2482 lto_symtab_encoder_iterator lsei
;
2484 fprintf (symtab
->dump_file
, "Writing partition %s to file %s, %i insns\n",
2485 part
->name
, temp_filename
, part
->insns
);
2486 fprintf (symtab
->dump_file
, " Symbols in partition: ");
2487 for (lsei
= lsei_start_in_partition (part
->encoder
); !lsei_end_p (lsei
);
2488 lsei_next_in_partition (&lsei
))
2490 symtab_node
*node
= lsei_node (lsei
);
2491 fprintf (symtab
->dump_file
, "%s ", node
->asm_name ());
2493 fprintf (symtab
->dump_file
, "\n Symbols in boundary: ");
2494 for (lsei
= lsei_start (part
->encoder
); !lsei_end_p (lsei
);
2497 symtab_node
*node
= lsei_node (lsei
);
2498 if (!lto_symtab_encoder_in_partition_p (part
->encoder
, node
))
2500 fprintf (symtab
->dump_file
, "%s ", node
->asm_name ());
2501 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
);
2503 && lto_symtab_encoder_encode_body_p (part
->encoder
, cnode
))
2504 fprintf (symtab
->dump_file
, "(body included)");
2507 varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
);
2509 && lto_symtab_encoder_encode_initializer_p (part
->encoder
, vnode
))
2510 fprintf (symtab
->dump_file
, "(initializer included)");
2514 fprintf (symtab
->dump_file
, "\n");
2516 gcc_checking_assert (lto_symtab_encoder_size (part
->encoder
) || !i
);
2518 stream_out (temp_filename
, part
->encoder
, i
== n_sets
- 1, i
);
2520 part
->encoder
= NULL
;
2522 temp_priority
.safe_push (part
->insns
);
2523 temp_filenames
.safe_push (xstrdup (temp_filename
));
2525 ltrans_output_list_stream
= fopen (ltrans_output_list
, "w");
2526 if (ltrans_output_list_stream
== NULL
)
2527 fatal_error (input_location
,
2528 "opening LTRANS output list %s: %m", ltrans_output_list
);
2529 for (i
= 0; i
< n_sets
; i
++)
2531 unsigned int len
= strlen (temp_filenames
[i
]);
2532 if (fprintf (ltrans_output_list_stream
, "%i\n", temp_priority
[i
]) < 0
2533 || fwrite (temp_filenames
[i
], 1, len
, ltrans_output_list_stream
) < len
2534 || fwrite ("\n", 1, 1, ltrans_output_list_stream
) < 1)
2535 fatal_error (input_location
, "writing to LTRANS output list %s: %m",
2536 ltrans_output_list
);
2537 free (temp_filenames
[i
]);
2540 lto_stats
.num_output_files
+= n_sets
;
2542 /* Close the LTRANS output list. */
2543 if (fclose (ltrans_output_list_stream
))
2544 fatal_error (input_location
,
2545 "closing LTRANS output list %s: %m", ltrans_output_list
);
2547 free_ltrans_partitions();
2548 free (temp_filename
);
2550 timevar_pop (TV_WHOPR_WPA_IO
);
2554 /* If TT is a variable or function decl replace it with its
2555 prevailing variant. */
2556 #define LTO_SET_PREVAIL(tt) \
2558 if ((tt) && VAR_OR_FUNCTION_DECL_P (tt) \
2559 && (TREE_PUBLIC (tt) || DECL_EXTERNAL (tt))) \
2561 tt = lto_symtab_prevailing_decl (tt); \
2566 /* Ensure that TT isn't a replacable var of function decl. */
2567 #define LTO_NO_PREVAIL(tt) \
2568 gcc_checking_assert (!(tt) || !VAR_OR_FUNCTION_DECL_P (tt))
2570 /* Given a tree T replace all fields referring to variables or functions
2571 with their prevailing variant. */
2573 lto_fixup_prevailing_decls (tree t
)
2575 enum tree_code code
= TREE_CODE (t
);
2578 gcc_checking_assert (code
!= TREE_BINFO
);
2579 LTO_NO_PREVAIL (TREE_TYPE (t
));
2580 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
)
2581 /* lto_symtab_prevail_decl use TREE_CHAIN to link to the prevailing decl.
2582 in the case T is a prevailed declaration we would ICE here. */
2583 && !VAR_OR_FUNCTION_DECL_P (t
))
2584 LTO_NO_PREVAIL (TREE_CHAIN (t
));
2587 LTO_NO_PREVAIL (DECL_NAME (t
));
2588 LTO_SET_PREVAIL (DECL_CONTEXT (t
));
2589 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
2591 LTO_SET_PREVAIL (DECL_SIZE (t
));
2592 LTO_SET_PREVAIL (DECL_SIZE_UNIT (t
));
2593 LTO_SET_PREVAIL (DECL_INITIAL (t
));
2594 LTO_NO_PREVAIL (DECL_ATTRIBUTES (t
));
2595 LTO_SET_PREVAIL (DECL_ABSTRACT_ORIGIN (t
));
2597 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
2599 LTO_NO_PREVAIL (DECL_ASSEMBLER_NAME_RAW (t
));
2601 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
2603 LTO_NO_PREVAIL (DECL_RESULT_FLD (t
));
2605 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
2607 LTO_NO_PREVAIL (DECL_ARGUMENTS (t
));
2608 LTO_SET_PREVAIL (DECL_FUNCTION_PERSONALITY (t
));
2609 LTO_NO_PREVAIL (DECL_VINDEX (t
));
2611 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
2613 LTO_SET_PREVAIL (DECL_FIELD_OFFSET (t
));
2614 LTO_NO_PREVAIL (DECL_BIT_FIELD_TYPE (t
));
2615 LTO_NO_PREVAIL (DECL_QUALIFIER (t
));
2616 LTO_NO_PREVAIL (DECL_FIELD_BIT_OFFSET (t
));
2617 LTO_NO_PREVAIL (DECL_FCONTEXT (t
));
2620 else if (TYPE_P (t
))
2622 LTO_NO_PREVAIL (TYPE_CACHED_VALUES (t
));
2623 LTO_SET_PREVAIL (TYPE_SIZE (t
));
2624 LTO_SET_PREVAIL (TYPE_SIZE_UNIT (t
));
2625 LTO_NO_PREVAIL (TYPE_ATTRIBUTES (t
));
2626 LTO_NO_PREVAIL (TYPE_NAME (t
));
2628 LTO_SET_PREVAIL (TYPE_MIN_VALUE_RAW (t
));
2629 LTO_SET_PREVAIL (TYPE_MAX_VALUE_RAW (t
));
2630 LTO_NO_PREVAIL (TYPE_LANG_SLOT_1 (t
));
2632 LTO_SET_PREVAIL (TYPE_CONTEXT (t
));
2634 LTO_NO_PREVAIL (TYPE_CANONICAL (t
));
2635 LTO_NO_PREVAIL (TYPE_MAIN_VARIANT (t
));
2636 LTO_NO_PREVAIL (TYPE_NEXT_VARIANT (t
));
2638 else if (EXPR_P (t
))
2641 for (i
= TREE_OPERAND_LENGTH (t
) - 1; i
>= 0; --i
)
2642 LTO_SET_PREVAIL (TREE_OPERAND (t
, i
));
2644 else if (TREE_CODE (t
) == CONSTRUCTOR
)
2648 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), i
, val
)
2649 LTO_SET_PREVAIL (val
);
2656 LTO_SET_PREVAIL (TREE_VALUE (t
));
2657 LTO_SET_PREVAIL (TREE_PURPOSE (t
));
2658 LTO_NO_PREVAIL (TREE_PURPOSE (t
));
2664 /* If we fixed nothing, then we missed something seen by
2666 gcc_checking_assert (fixed
);
2668 #undef LTO_SET_PREVAIL
2669 #undef LTO_NO_PREVAIL
2671 /* Helper function of lto_fixup_decls. Walks the var and fn streams in STATE,
2672 replaces var and function decls with the corresponding prevailing def. */
2675 lto_fixup_state (struct lto_in_decl_state
*state
)
2679 /* Although we only want to replace FUNCTION_DECLs and VAR_DECLs,
2680 we still need to walk from all DECLs to find the reachable
2681 FUNCTION_DECLs and VAR_DECLs. */
2682 for (si
= 0; si
< LTO_N_DECL_STREAMS
; si
++)
2684 vec
<tree
, va_gc
> *trees
= state
->streams
[si
];
2685 for (i
= 0; i
< vec_safe_length (trees
); i
++)
2687 tree t
= (*trees
)[i
];
2688 if (flag_checking
&& TYPE_P (t
))
2690 if (VAR_OR_FUNCTION_DECL_P (t
)
2691 && (TREE_PUBLIC (t
) || DECL_EXTERNAL (t
)))
2692 (*trees
)[i
] = lto_symtab_prevailing_decl (t
);
2697 /* Fix the decls from all FILES. Replaces each decl with the corresponding
2701 lto_fixup_decls (struct lto_file_decl_data
**files
)
2707 FOR_EACH_VEC_ELT ((*tree_with_vars
), i
, t
)
2708 lto_fixup_prevailing_decls (t
);
2710 for (i
= 0; files
[i
]; i
++)
2712 struct lto_file_decl_data
*file
= files
[i
];
2713 struct lto_in_decl_state
*state
= file
->global_decl_state
;
2714 lto_fixup_state (state
);
2716 hash_table
<decl_state_hasher
>::iterator iter
;
2717 lto_in_decl_state
*elt
;
2718 FOR_EACH_HASH_TABLE_ELEMENT (*file
->function_decl_states
, elt
,
2719 lto_in_decl_state
*, iter
)
2720 lto_fixup_state (elt
);
2724 static GTY((length ("lto_stats.num_input_files + 1"))) struct lto_file_decl_data
**all_file_decl_data
;
2726 /* Turn file datas for sub files into a single array, so that they look
2727 like separate files for further passes. */
2730 lto_flatten_files (struct lto_file_decl_data
**orig
, int count
, int last_file_ix
)
2732 struct lto_file_decl_data
*n
, *next
;
2735 lto_stats
.num_input_files
= count
;
2737 = ggc_cleared_vec_alloc
<lto_file_decl_data_ptr
> (count
+ 1);
2738 /* Set the hooks so that all of the ipa passes can read in their data. */
2739 lto_set_in_hooks (all_file_decl_data
, get_section_data
, free_section_data
);
2740 for (i
= 0, k
= 0; i
< last_file_ix
; i
++)
2742 for (n
= orig
[i
]; n
!= NULL
; n
= next
)
2744 all_file_decl_data
[k
++] = n
;
2749 all_file_decl_data
[k
] = NULL
;
2750 gcc_assert (k
== count
);
2753 /* Input file data before flattening (i.e. splitting them to subfiles to support
2754 incremental linking. */
2755 static int real_file_count
;
2756 static GTY((length ("real_file_count + 1"))) struct lto_file_decl_data
**real_file_decl_data
;
2758 static void print_lto_report_1 (void);
2760 /* Read all the symbols from the input files FNAMES. NFILES is the
2761 number of files requested in the command line. Instantiate a
2762 global call graph by aggregating all the sub-graphs found in each
2766 read_cgraph_and_symbols (unsigned nfiles
, const char **fnames
)
2768 unsigned int i
, last_file_ix
;
2771 struct lto_file_decl_data
**decl_data
;
2774 symtab
->initialize ();
2776 timevar_push (TV_IPA_LTO_DECL_IN
);
2778 #ifdef ACCEL_COMPILER
2779 section_name_prefix
= OFFLOAD_SECTION_NAME_PREFIX
;
2780 lto_stream_offload_p
= true;
2784 = decl_data
= ggc_cleared_vec_alloc
<lto_file_decl_data_ptr
> (nfiles
+ 1);
2785 real_file_count
= nfiles
;
2787 /* Read the resolution file. */
2789 if (resolution_file_name
)
2792 unsigned num_objects
;
2794 resolution
= fopen (resolution_file_name
, "r");
2795 if (resolution
== NULL
)
2796 fatal_error (input_location
,
2797 "could not open symbol resolution file: %m");
2799 t
= fscanf (resolution
, "%u", &num_objects
);
2800 gcc_assert (t
== 1);
2802 /* True, since the plugin splits the archives. */
2803 gcc_assert (num_objects
== nfiles
);
2805 symtab
->state
= LTO_STREAMING
;
2807 canonical_type_hash_cache
= new hash_map
<const_tree
, hashval_t
> (251);
2808 gimple_canonical_types
= htab_create (16381, gimple_canonical_type_hash
,
2809 gimple_canonical_type_eq
, NULL
);
2810 gcc_obstack_init (&tree_scc_hash_obstack
);
2811 tree_scc_hash
= new hash_table
<tree_scc_hasher
> (4096);
2813 /* Register the common node types with the canonical type machinery so
2814 we properly share alias-sets across languages and TUs. Do not
2815 expose the common nodes as type merge target - those that should be
2816 are already exposed so by pre-loading the LTO streamer caches.
2817 Do two passes - first clear TYPE_CANONICAL and then re-compute it. */
2818 for (i
= 0; i
< itk_none
; ++i
)
2819 lto_register_canonical_types (integer_types
[i
], true);
2820 for (i
= 0; i
< stk_type_kind_last
; ++i
)
2821 lto_register_canonical_types (sizetype_tab
[i
], true);
2822 for (i
= 0; i
< TI_MAX
; ++i
)
2823 lto_register_canonical_types (global_trees
[i
], true);
2824 for (i
= 0; i
< itk_none
; ++i
)
2825 lto_register_canonical_types (integer_types
[i
], false);
2826 for (i
= 0; i
< stk_type_kind_last
; ++i
)
2827 lto_register_canonical_types (sizetype_tab
[i
], false);
2828 for (i
= 0; i
< TI_MAX
; ++i
)
2829 lto_register_canonical_types (global_trees
[i
], false);
2832 fprintf (stderr
, "Reading object files:");
2834 /* Read all of the object files specified on the command line. */
2835 for (i
= 0, last_file_ix
= 0; i
< nfiles
; ++i
)
2837 struct lto_file_decl_data
*file_data
= NULL
;
2840 fprintf (stderr
, " %s", fnames
[i
]);
2844 current_lto_file
= lto_obj_file_open (fnames
[i
], false);
2845 if (!current_lto_file
)
2848 file_data
= lto_file_read (current_lto_file
, resolution
, &count
);
2851 lto_obj_file_close (current_lto_file
);
2852 free (current_lto_file
);
2853 current_lto_file
= NULL
;
2857 decl_data
[last_file_ix
++] = file_data
;
2859 lto_obj_file_close (current_lto_file
);
2860 free (current_lto_file
);
2861 current_lto_file
= NULL
;
2864 lto_flatten_files (decl_data
, count
, last_file_ix
);
2865 lto_stats
.num_input_files
= count
;
2866 ggc_free(decl_data
);
2867 real_file_decl_data
= NULL
;
2869 if (resolution_file_name
)
2870 fclose (resolution
);
2872 /* Show the LTO report before launching LTRANS. */
2873 if (flag_lto_report
|| (flag_wpa
&& flag_lto_report_wpa
))
2874 print_lto_report_1 ();
2876 /* Free gimple type merging datastructures. */
2877 delete tree_scc_hash
;
2878 tree_scc_hash
= NULL
;
2879 obstack_free (&tree_scc_hash_obstack
, NULL
);
2880 htab_delete (gimple_canonical_types
);
2881 gimple_canonical_types
= NULL
;
2882 delete canonical_type_hash_cache
;
2883 canonical_type_hash_cache
= NULL
;
2885 /* At this stage we know that majority of GGC memory is reachable.
2886 Growing the limits prevents unnecesary invocation of GGC. */
2890 /* Set the hooks so that all of the ipa passes can read in their data. */
2891 lto_set_in_hooks (all_file_decl_data
, get_section_data
, free_section_data
);
2893 timevar_pop (TV_IPA_LTO_DECL_IN
);
2896 fprintf (stderr
, "\nReading the callgraph\n");
2898 timevar_push (TV_IPA_LTO_CGRAPH_IO
);
2899 /* Read the symtab. */
2902 input_offload_tables (!flag_ltrans
);
2904 /* Store resolutions into the symbol table. */
2906 FOR_EACH_SYMBOL (snode
)
2907 if (snode
->externally_visible
&& snode
->real_symbol_p ()
2908 && snode
->lto_file_data
&& snode
->lto_file_data
->resolution_map
2909 && !is_builtin_fn (snode
->decl
)
2910 && !(VAR_P (snode
->decl
) && DECL_HARD_REGISTER (snode
->decl
)))
2912 ld_plugin_symbol_resolution_t
*res
;
2914 res
= snode
->lto_file_data
->resolution_map
->get (snode
->decl
);
2915 if (!res
|| *res
== LDPR_UNKNOWN
)
2917 if (snode
->output_to_lto_symbol_table_p ())
2918 fatal_error (input_location
, "missing resolution data for %s",
2920 (DECL_ASSEMBLER_NAME (snode
->decl
)));
2923 snode
->resolution
= *res
;
2925 for (i
= 0; all_file_decl_data
[i
]; i
++)
2926 if (all_file_decl_data
[i
]->resolution_map
)
2928 delete all_file_decl_data
[i
]->resolution_map
;
2929 all_file_decl_data
[i
]->resolution_map
= NULL
;
2932 timevar_pop (TV_IPA_LTO_CGRAPH_IO
);
2935 fprintf (stderr
, "Merging declarations\n");
2937 timevar_push (TV_IPA_LTO_DECL_MERGE
);
2938 /* Merge global decls. In ltrans mode we read merged cgraph, we do not
2939 need to care about resolving symbols again, we only need to replace
2940 duplicated declarations read from the callgraph and from function
2944 lto_symtab_merge_decls ();
2946 /* If there were errors during symbol merging bail out, we have no
2947 good way to recover here. */
2949 fatal_error (input_location
,
2950 "errors during merging of translation units");
2952 /* Fixup all decls. */
2953 lto_fixup_decls (all_file_decl_data
);
2956 ggc_free (tree_with_vars
);
2957 tree_with_vars
= NULL
;
2960 timevar_pop (TV_IPA_LTO_DECL_MERGE
);
2961 /* Each pass will set the appropriate timer. */
2964 fprintf (stderr
, "Reading summaries\n");
2966 /* Read the IPA summary data. */
2968 ipa_read_optimization_summaries ();
2970 ipa_read_summaries ();
2972 for (i
= 0; all_file_decl_data
[i
]; i
++)
2974 gcc_assert (all_file_decl_data
[i
]->symtab_node_encoder
);
2975 lto_symtab_encoder_delete (all_file_decl_data
[i
]->symtab_node_encoder
);
2976 all_file_decl_data
[i
]->symtab_node_encoder
= NULL
;
2977 lto_free_function_in_decl_state (all_file_decl_data
[i
]->global_decl_state
);
2978 all_file_decl_data
[i
]->global_decl_state
= NULL
;
2979 all_file_decl_data
[i
]->current_decl_state
= NULL
;
2984 /* Finally merge the cgraph according to the decl merging decisions. */
2985 timevar_push (TV_IPA_LTO_CGRAPH_MERGE
);
2987 gcc_assert (!dump_file
);
2988 dump_file
= dump_begin (lto_link_dump_id
, NULL
);
2992 fprintf (dump_file
, "Before merging:\n");
2993 symtab
->dump (dump_file
);
2995 lto_symtab_merge_symbols ();
2996 /* Removal of unreachable symbols is needed to make verify_symtab to pass;
2997 we are still having duplicated comdat groups containing local statics.
2998 We could also just remove them while merging. */
2999 symtab
->remove_unreachable_nodes (dump_file
);
3003 dump_end (lto_link_dump_id
, dump_file
);
3005 timevar_pop (TV_IPA_LTO_CGRAPH_MERGE
);
3007 symtab
->state
= IPA_SSA
;
3008 /* All node removals happening here are useless, because
3009 WPA should not stream them. Still always perform remove_unreachable_nodes
3010 because we may reshape clone tree, get rid of dead masters of inline
3011 clones and remove symbol entries for read-only variables we keep around
3012 only to be able to constant fold them. */
3015 if (symtab
->dump_file
)
3016 symtab
->dump (symtab
->dump_file
);
3017 symtab
->remove_unreachable_nodes (symtab
->dump_file
);
3020 /* Indicate that the cgraph is built and ready. */
3021 symtab
->function_flags_ready
= true;
3023 ggc_free (all_file_decl_data
);
3024 all_file_decl_data
= NULL
;
3028 /* Materialize all the bodies for all the nodes in the callgraph. */
3031 materialize_cgraph (void)
3033 struct cgraph_node
*node
;
3034 timevar_id_t lto_timer
;
3038 flag_wpa
? "Materializing decls:" : "Reading function bodies:");
3041 FOR_EACH_FUNCTION (node
)
3043 if (node
->lto_file_data
)
3045 lto_materialize_function (node
);
3046 lto_stats
.num_input_cgraph_nodes
++;
3051 /* Start the appropriate timer depending on the mode that we are
3053 lto_timer
= (flag_wpa
) ? TV_WHOPR_WPA
3054 : (flag_ltrans
) ? TV_WHOPR_LTRANS
3056 timevar_push (lto_timer
);
3058 current_function_decl
= NULL
;
3062 fprintf (stderr
, "\n");
3064 timevar_pop (lto_timer
);
3068 /* Show various memory usage statistics related to LTO. */
3070 print_lto_report_1 (void)
3072 const char *pfx
= (flag_lto
) ? "LTO" : (flag_wpa
) ? "WPA" : "LTRANS";
3073 fprintf (stderr
, "%s statistics\n", pfx
);
3075 fprintf (stderr
, "[%s] read %lu SCCs of average size %f\n",
3076 pfx
, num_sccs_read
, total_scc_size
/ (double)num_sccs_read
);
3077 fprintf (stderr
, "[%s] %lu tree bodies read in total\n", pfx
, total_scc_size
);
3078 if (flag_wpa
&& tree_scc_hash
)
3080 fprintf (stderr
, "[%s] tree SCC table: size %ld, %ld elements, "
3081 "collision ratio: %f\n", pfx
,
3082 (long) tree_scc_hash
->size (),
3083 (long) tree_scc_hash
->elements (),
3084 tree_scc_hash
->collisions ());
3085 hash_table
<tree_scc_hasher
>::iterator hiter
;
3086 tree_scc
*scc
, *max_scc
= NULL
;
3087 unsigned max_length
= 0;
3088 FOR_EACH_HASH_TABLE_ELEMENT (*tree_scc_hash
, scc
, x
, hiter
)
3090 unsigned length
= 0;
3092 for (; s
; s
= s
->next
)
3094 if (length
> max_length
)
3096 max_length
= length
;
3100 fprintf (stderr
, "[%s] tree SCC max chain length %u (size %u)\n",
3101 pfx
, max_length
, max_scc
->len
);
3102 fprintf (stderr
, "[%s] Compared %lu SCCs, %lu collisions (%f)\n", pfx
,
3103 num_scc_compares
, num_scc_compare_collisions
,
3104 num_scc_compare_collisions
/ (double) num_scc_compares
);
3105 fprintf (stderr
, "[%s] Merged %lu SCCs\n", pfx
, num_sccs_merged
);
3106 fprintf (stderr
, "[%s] Merged %lu tree bodies\n", pfx
,
3107 total_scc_size_merged
);
3108 fprintf (stderr
, "[%s] Merged %lu types\n", pfx
, num_merged_types
);
3109 fprintf (stderr
, "[%s] %lu types prevailed (%lu associated trees)\n",
3110 pfx
, num_prevailing_types
, num_type_scc_trees
);
3111 fprintf (stderr
, "[%s] GIMPLE canonical type table: size %ld, "
3112 "%ld elements, %ld searches, %ld collisions (ratio: %f)\n", pfx
,
3113 (long) htab_size (gimple_canonical_types
),
3114 (long) htab_elements (gimple_canonical_types
),
3115 (long) gimple_canonical_types
->searches
,
3116 (long) gimple_canonical_types
->collisions
,
3117 htab_collisions (gimple_canonical_types
));
3118 fprintf (stderr
, "[%s] GIMPLE canonical type pointer-map: "
3119 "%lu elements, %ld searches\n", pfx
,
3120 num_canonical_type_hash_entries
,
3121 num_canonical_type_hash_queries
);
3124 print_lto_report (pfx
);
3127 /* Perform whole program analysis (WPA) on the callgraph and write out the
3128 optimization plan. */
3131 do_whole_program_analysis (void)
3135 lto_parallelism
= 1;
3137 /* TODO: jobserver communicatoin is not supported, yet. */
3138 if (!strcmp (flag_wpa
, "jobserver"))
3139 lto_parallelism
= -1;
3142 lto_parallelism
= atoi (flag_wpa
);
3143 if (lto_parallelism
<= 0)
3144 lto_parallelism
= 0;
3147 timevar_start (TV_PHASE_OPT_GEN
);
3149 /* Note that since we are in WPA mode, materialize_cgraph will not
3150 actually read in all the function bodies. It only materializes
3151 the decls and cgraph nodes so that analysis can be performed. */
3152 materialize_cgraph ();
3154 /* Reading in the cgraph uses different timers, start timing WPA now. */
3155 timevar_push (TV_WHOPR_WPA
);
3157 if (pre_ipa_mem_report
)
3159 fprintf (stderr
, "Memory consumption before IPA\n");
3160 dump_memory_report (false);
3163 symtab
->function_flags_ready
= true;
3165 if (symtab
->dump_file
)
3166 symtab
->dump (symtab
->dump_file
);
3167 bitmap_obstack_initialize (NULL
);
3168 symtab
->state
= IPA_SSA
;
3170 execute_ipa_pass_list (g
->get_passes ()->all_regular_ipa_passes
);
3172 /* When WPA analysis raises errors, do not bother to output anything. */
3176 /* We are about to launch the final LTRANS phase, stop the WPA timer. */
3177 timevar_pop (TV_WHOPR_WPA
);
3179 timevar_push (TV_WHOPR_PARTITIONING
);
3181 gcc_assert (!dump_file
);
3182 dump_file
= dump_begin (partition_dump_id
, NULL
);
3185 symtab
->dump (dump_file
);
3187 symtab_node::checking_verify_symtab_nodes ();
3188 bitmap_obstack_release (NULL
);
3189 if (flag_lto_partition
== LTO_PARTITION_1TO1
)
3191 else if (flag_lto_partition
== LTO_PARTITION_MAX
)
3193 else if (flag_lto_partition
== LTO_PARTITION_ONE
)
3194 lto_balanced_map (1, INT_MAX
);
3195 else if (flag_lto_partition
== LTO_PARTITION_BALANCED
)
3196 lto_balanced_map (PARAM_VALUE (PARAM_LTO_PARTITIONS
),
3197 PARAM_VALUE (MAX_PARTITION_SIZE
));
3201 /* Inline summaries are needed for balanced partitioning. Free them now so
3202 the memory can be used for streamer caches. */
3203 ipa_free_fn_summary ();
3205 /* AUX pointers are used by partitioning code to bookkeep number of
3206 partitions symbol is in. This is no longer needed. */
3207 FOR_EACH_SYMBOL (node
)
3210 lto_stats
.num_cgraph_partitions
+= ltrans_partitions
.length ();
3212 /* Find out statics that need to be promoted
3213 to globals with hidden visibility because they are accessed from multiple
3215 lto_promote_cross_file_statics ();
3217 dump_end (partition_dump_id
, dump_file
);
3219 timevar_pop (TV_WHOPR_PARTITIONING
);
3221 timevar_stop (TV_PHASE_OPT_GEN
);
3223 /* Collect a last time - in lto_wpa_write_files we may end up forking
3224 with the idea that this doesn't increase memory usage. So we
3225 absoultely do not want to collect after that. */
3228 timevar_start (TV_PHASE_STREAM_OUT
);
3231 fprintf (stderr
, "\nStreaming out");
3234 lto_wpa_write_files ();
3236 fprintf (stderr
, "\n");
3237 timevar_stop (TV_PHASE_STREAM_OUT
);
3239 if (post_ipa_mem_report
)
3241 fprintf (stderr
, "Memory consumption after IPA\n");
3242 dump_memory_report (false);
3245 /* Show the LTO report before launching LTRANS. */
3246 if (flag_lto_report
|| (flag_wpa
&& flag_lto_report_wpa
))
3247 print_lto_report_1 ();
3249 dump_memory_report (true);
3253 static GTY(()) tree lto_eh_personality_decl
;
3255 /* Return the LTO personality function decl. */
3258 lto_eh_personality (void)
3260 if (!lto_eh_personality_decl
)
3262 /* Use the first personality DECL for our personality if we don't
3263 support multiple ones. This ensures that we don't artificially
3264 create the need for them in a single-language program. */
3265 if (first_personality_decl
&& !dwarf2out_do_cfi_asm ())
3266 lto_eh_personality_decl
= first_personality_decl
;
3268 lto_eh_personality_decl
= lhd_gcc_personality ();
3271 return lto_eh_personality_decl
;
3274 /* Set the process name based on the LTO mode. */
3277 lto_process_name (void)
3280 setproctitle (flag_incremental_link
== INCREMENTAL_LINK_LTO
3281 ? "lto1-inclink" : "lto1-lto");
3283 setproctitle ("lto1-wpa");
3285 setproctitle ("lto1-ltrans");
3289 /* Initialize the LTO front end. */
3294 lto_process_name ();
3295 lto_streamer_hooks_init ();
3297 lto_set_in_hooks (NULL
, get_section_data
, free_section_data
);
3298 memset (<o_stats
, 0, sizeof (lto_stats
));
3299 bitmap_obstack_initialize (NULL
);
3300 gimple_register_cfg_hooks ();
3301 #ifndef ACCEL_COMPILER
3302 unsigned char *table
3303 = ggc_vec_alloc
<unsigned char> (MAX_MACHINE_MODE
);
3304 for (int m
= 0; m
< MAX_MACHINE_MODE
; m
++)
3306 lto_mode_identity_table
= table
;
3310 /* Create artificial pointers for "omp declare target link" vars. */
3313 offload_handle_link_vars (void)
3315 #ifdef ACCEL_COMPILER
3317 FOR_EACH_VARIABLE (var
)
3318 if (lookup_attribute ("omp declare target link",
3319 DECL_ATTRIBUTES (var
->decl
)))
3321 tree type
= build_pointer_type (TREE_TYPE (var
->decl
));
3322 tree link_ptr_var
= make_node (VAR_DECL
);
3323 TREE_TYPE (link_ptr_var
) = type
;
3324 TREE_USED (link_ptr_var
) = 1;
3325 TREE_STATIC (link_ptr_var
) = 1;
3326 SET_DECL_MODE (link_ptr_var
, TYPE_MODE (type
));
3327 DECL_SIZE (link_ptr_var
) = TYPE_SIZE (type
);
3328 DECL_SIZE_UNIT (link_ptr_var
) = TYPE_SIZE_UNIT (type
);
3329 DECL_ARTIFICIAL (link_ptr_var
) = 1;
3330 tree var_name
= DECL_ASSEMBLER_NAME (var
->decl
);
3332 = ACONCAT ((IDENTIFIER_POINTER (var_name
), "_linkptr", NULL
));
3333 DECL_NAME (link_ptr_var
) = get_identifier (new_name
);
3334 SET_DECL_ASSEMBLER_NAME (link_ptr_var
, DECL_NAME (link_ptr_var
));
3335 SET_DECL_VALUE_EXPR (var
->decl
, build_simple_mem_ref (link_ptr_var
));
3336 DECL_HAS_VALUE_EXPR_P (var
->decl
) = 1;
3342 /* Main entry point for the GIMPLE front end. This front end has
3343 three main personalities:
3345 - LTO (-flto). All the object files on the command line are
3346 loaded in memory and processed as a single translation unit.
3347 This is the traditional link-time optimization behavior.
3349 - WPA (-fwpa). Only the callgraph and summary information for
3350 files in the command file are loaded. A single callgraph
3351 (without function bodies) is instantiated for the whole set of
3352 files. IPA passes are only allowed to analyze the call graph
3353 and make transformation decisions. The callgraph is
3354 partitioned, each partition is written to a new object file
3355 together with the transformation decisions.
3357 - LTRANS (-fltrans). Similar to -flto but it prevents the IPA
3358 summary files from running again. Since WPA computed summary
3359 information and decided what transformations to apply, LTRANS
3360 simply applies them. */
3365 /* LTO is called as a front end, even though it is not a front end.
3366 Because it is called as a front end, TV_PHASE_PARSING and
3367 TV_PARSE_GLOBAL are active, and we need to turn them off while
3368 doing LTO. Later we turn them back on so they are active up in
3370 timevar_pop (TV_PARSE_GLOBAL
);
3371 timevar_stop (TV_PHASE_PARSING
);
3373 timevar_start (TV_PHASE_SETUP
);
3375 /* Initialize the LTO front end. */
3378 timevar_stop (TV_PHASE_SETUP
);
3379 timevar_start (TV_PHASE_STREAM_IN
);
3381 /* Read all the symbols and call graph from all the files in the
3383 read_cgraph_and_symbols (num_in_fnames
, in_fnames
);
3385 timevar_stop (TV_PHASE_STREAM_IN
);
3389 offload_handle_link_vars ();
3391 /* If WPA is enabled analyze the whole call graph and create an
3392 optimization plan. Otherwise, read in all the function
3393 bodies and continue with optimization. */
3395 do_whole_program_analysis ();
3398 timevar_start (TV_PHASE_OPT_GEN
);
3400 materialize_cgraph ();
3402 lto_promote_statics_nonwpa ();
3404 /* Annotate the CU DIE and mark the early debug phase as finished. */
3405 debug_hooks
->early_finish ("<artificial>");
3407 /* Let the middle end know that we have read and merged all of
3411 timevar_stop (TV_PHASE_OPT_GEN
);
3413 /* FIXME lto, if the processes spawned by WPA fail, we miss
3414 the chance to print WPA's report, so WPA will call
3415 print_lto_report before launching LTRANS. If LTRANS was
3416 launched directly by the driver we would not need to do
3418 if (flag_lto_report
|| (flag_wpa
&& flag_lto_report_wpa
))
3419 print_lto_report_1 ();
3423 /* Here we make LTO pretend to be a parser. */
3424 timevar_start (TV_PHASE_PARSING
);
3425 timevar_push (TV_PARSE_GLOBAL
);
3428 #include "gt-lto-lto.h"