1 /* Top-level LTO routines.
2 Copyright (C) 2009-2015 Free Software Foundation, Inc.
3 Contributed by CodeSourcery, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
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"
43 #include "lto-section-names.h"
44 #include "splay-tree.h"
45 #include "lto-partition.h"
47 #include "pass_manager.h"
48 #include "ipa-inline.h"
50 #include "ipa-utils.h"
51 #include "gomp-constants.h"
52 #include "lto-symtab.h"
55 /* Number of parallel tasks to run, -1 if we want to use GNU Make jobserver. */
56 static int lto_parallelism
;
58 static GTY(()) tree first_personality_decl
;
60 static GTY(()) const unsigned char *lto_mode_identity_table
;
62 /* Returns a hash code for P. */
65 hash_name (const void *p
)
67 const struct lto_section_slot
*ds
= (const struct lto_section_slot
*) p
;
68 return (hashval_t
) htab_hash_string (ds
->name
);
72 /* Returns nonzero if P1 and P2 are equal. */
75 eq_name (const void *p1
, const void *p2
)
77 const struct lto_section_slot
*s1
=
78 (const struct lto_section_slot
*) p1
;
79 const struct lto_section_slot
*s2
=
80 (const struct lto_section_slot
*) p2
;
82 return strcmp (s1
->name
, s2
->name
) == 0;
85 /* Free lto_section_slot */
88 free_with_string (void *arg
)
90 struct lto_section_slot
*s
= (struct lto_section_slot
*)arg
;
92 free (CONST_CAST (char *, s
->name
));
96 /* Create section hash table */
99 lto_obj_create_section_hash_table (void)
101 return htab_create (37, hash_name
, eq_name
, free_with_string
);
104 /* Delete an allocated integer KEY in the splay tree. */
107 lto_splay_tree_delete_id (splay_tree_key key
)
112 /* Compare splay tree node ids A and B. */
115 lto_splay_tree_compare_ids (splay_tree_key a
, splay_tree_key b
)
117 unsigned HOST_WIDE_INT ai
;
118 unsigned HOST_WIDE_INT bi
;
120 ai
= *(unsigned HOST_WIDE_INT
*) a
;
121 bi
= *(unsigned HOST_WIDE_INT
*) b
;
130 /* Look up splay tree node by ID in splay tree T. */
132 static splay_tree_node
133 lto_splay_tree_lookup (splay_tree t
, unsigned HOST_WIDE_INT id
)
135 return splay_tree_lookup (t
, (splay_tree_key
) &id
);
138 /* Check if KEY has ID. */
141 lto_splay_tree_id_equal_p (splay_tree_key key
, unsigned HOST_WIDE_INT id
)
143 return *(unsigned HOST_WIDE_INT
*) key
== id
;
146 /* Insert a splay tree node into tree T with ID as key and FILE_DATA as value.
147 The ID is allocated separately because we need HOST_WIDE_INTs which may
148 be wider than a splay_tree_key. */
151 lto_splay_tree_insert (splay_tree t
, unsigned HOST_WIDE_INT id
,
152 struct lto_file_decl_data
*file_data
)
154 unsigned HOST_WIDE_INT
*idp
= XCNEW (unsigned HOST_WIDE_INT
);
156 splay_tree_insert (t
, (splay_tree_key
) idp
, (splay_tree_value
) file_data
);
159 /* Create a splay tree. */
162 lto_splay_tree_new (void)
164 return splay_tree_new (lto_splay_tree_compare_ids
,
165 lto_splay_tree_delete_id
,
169 /* Return true when NODE has a clone that is analyzed (i.e. we need
170 to load its body even if the node itself is not needed). */
173 has_analyzed_clone_p (struct cgraph_node
*node
)
175 struct cgraph_node
*orig
= node
;
184 else if (node
->next_sibling_clone
)
185 node
= node
->next_sibling_clone
;
188 while (node
!= orig
&& !node
->next_sibling_clone
)
189 node
= node
->clone_of
;
191 node
= node
->next_sibling_clone
;
197 /* Read the function body for the function associated with NODE. */
200 lto_materialize_function (struct cgraph_node
*node
)
205 /* Read in functions with body (analyzed nodes)
206 and also functions that are needed to produce virtual clones. */
207 if ((node
->has_gimple_body_p () && node
->analyzed
)
208 || node
->used_as_abstract_origin
209 || has_analyzed_clone_p (node
))
211 /* Clones don't need to be read. */
214 if (DECL_FUNCTION_PERSONALITY (decl
) && !first_personality_decl
)
215 first_personality_decl
= DECL_FUNCTION_PERSONALITY (decl
);
218 /* Let the middle end know about the function. */
219 rest_of_decl_compilation (decl
, 1, 0);
223 /* Decode the content of memory pointed to by DATA in the in decl
224 state object STATE. DATA_IN points to a data_in structure for
225 decoding. Return the address after the decoded object in the
228 static const uint32_t *
229 lto_read_in_decl_state (struct data_in
*data_in
, const uint32_t *data
,
230 struct lto_in_decl_state
*state
)
237 state
->compressed
= ix
& 1;
239 decl
= streamer_tree_cache_get_tree (data_in
->reader_cache
, ix
);
240 if (!VAR_OR_FUNCTION_DECL_P (decl
))
242 gcc_assert (decl
== void_type_node
);
245 state
->fn_decl
= decl
;
247 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
249 uint32_t size
= *data
++;
250 vec
<tree
, va_gc
> *decls
= NULL
;
251 vec_alloc (decls
, size
);
253 for (j
= 0; j
< size
; j
++)
254 vec_safe_push (decls
,
255 streamer_tree_cache_get_tree (data_in
->reader_cache
,
258 state
->streams
[i
] = decls
;
266 /* Global canonical type table. */
267 static htab_t gimple_canonical_types
;
268 static hash_map
<const_tree
, hashval_t
> *canonical_type_hash_cache
;
269 static unsigned long num_canonical_type_hash_entries
;
270 static unsigned long num_canonical_type_hash_queries
;
272 static void iterative_hash_canonical_type (tree type
, inchash::hash
&hstate
);
273 static hashval_t
gimple_canonical_type_hash (const void *p
);
274 static void gimple_register_canonical_type_1 (tree t
, hashval_t hash
);
276 /* Returning a hash value for gimple type TYPE.
278 The hash value returned is equal for types considered compatible
279 by gimple_canonical_types_compatible_p. */
282 hash_canonical_type (tree type
)
284 inchash::hash hstate
;
287 /* We compute alias sets only for types that needs them.
288 Be sure we do not recurse to something else as we can not hash incomplete
289 types in a way they would have same hash value as compatible complete
291 gcc_checking_assert (type_with_alias_set_p (type
));
293 /* Combine a few common features of types so that types are grouped into
294 smaller sets; when searching for existing matching types to merge,
295 only existing types having the same features as the new type will be
297 code
= tree_code_for_canonical_type_merging (TREE_CODE (type
));
298 hstate
.add_int (code
);
299 hstate
.add_int (TYPE_MODE (type
));
301 /* Incorporate common features of numerical types. */
302 if (INTEGRAL_TYPE_P (type
)
303 || SCALAR_FLOAT_TYPE_P (type
)
304 || FIXED_POINT_TYPE_P (type
)
305 || TREE_CODE (type
) == OFFSET_TYPE
306 || POINTER_TYPE_P (type
))
308 hstate
.add_int (TYPE_PRECISION (type
));
309 if (!type_with_interoperable_signedness (type
))
310 hstate
.add_int (TYPE_UNSIGNED (type
));
313 if (VECTOR_TYPE_P (type
))
315 hstate
.add_int (TYPE_VECTOR_SUBPARTS (type
));
316 hstate
.add_int (TYPE_UNSIGNED (type
));
319 if (TREE_CODE (type
) == COMPLEX_TYPE
)
320 hstate
.add_int (TYPE_UNSIGNED (type
));
322 /* Fortran's C_SIGNED_CHAR is !TYPE_STRING_FLAG but needs to be
323 interoperable with "signed char". Unless all frontends are revisited to
324 agree on these types, we must ignore the flag completely. */
326 /* Fortran standard define C_PTR type that is compatible with every
327 C pointer. For this reason we need to glob all pointers into one.
328 Still pointers in different address spaces are not compatible. */
329 if (POINTER_TYPE_P (type
))
330 hstate
.add_int (TYPE_ADDR_SPACE (TREE_TYPE (type
)));
332 /* For array types hash the domain bounds and the string flag. */
333 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
335 hstate
.add_int (TYPE_STRING_FLAG (type
));
336 /* OMP lowering can introduce error_mark_node in place of
337 random local decls in types. */
338 if (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)) != error_mark_node
)
339 inchash::add_expr (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)), hstate
);
340 if (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != error_mark_node
)
341 inchash::add_expr (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)), hstate
);
344 /* Recurse for aggregates with a single element type. */
345 if (TREE_CODE (type
) == ARRAY_TYPE
346 || TREE_CODE (type
) == COMPLEX_TYPE
347 || TREE_CODE (type
) == VECTOR_TYPE
)
348 iterative_hash_canonical_type (TREE_TYPE (type
), hstate
);
350 /* Incorporate function return and argument types. */
351 if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
356 iterative_hash_canonical_type (TREE_TYPE (type
), hstate
);
358 for (p
= TYPE_ARG_TYPES (type
), na
= 0; p
; p
= TREE_CHAIN (p
))
360 iterative_hash_canonical_type (TREE_VALUE (p
), hstate
);
367 if (RECORD_OR_UNION_TYPE_P (type
))
372 for (f
= TYPE_FIELDS (type
), nf
= 0; f
; f
= TREE_CHAIN (f
))
373 if (TREE_CODE (f
) == FIELD_DECL
)
375 iterative_hash_canonical_type (TREE_TYPE (f
), hstate
);
385 /* Returning a hash value for gimple type TYPE combined with VAL. */
388 iterative_hash_canonical_type (tree type
, inchash::hash
&hstate
)
392 /* All type variants have same TYPE_CANONICAL. */
393 type
= TYPE_MAIN_VARIANT (type
);
395 if (!canonical_type_used_p (type
))
396 v
= hash_canonical_type (type
);
397 /* An already processed type. */
398 else if (TYPE_CANONICAL (type
))
400 type
= TYPE_CANONICAL (type
);
401 v
= gimple_canonical_type_hash (type
);
405 /* Canonical types should not be able to form SCCs by design, this
406 recursion is just because we do not register canonical types in
407 optimal order. To avoid quadratic behavior also register the
409 v
= hash_canonical_type (type
);
410 gimple_register_canonical_type_1 (type
, v
);
415 /* Returns the hash for a canonical type P. */
418 gimple_canonical_type_hash (const void *p
)
420 num_canonical_type_hash_queries
++;
421 hashval_t
*slot
= canonical_type_hash_cache
->get ((const_tree
) p
);
422 gcc_assert (slot
!= NULL
);
428 /* Returns nonzero if P1 and P2 are equal. */
431 gimple_canonical_type_eq (const void *p1
, const void *p2
)
433 const_tree t1
= (const_tree
) p1
;
434 const_tree t2
= (const_tree
) p2
;
435 return gimple_canonical_types_compatible_p (CONST_CAST_TREE (t1
),
436 CONST_CAST_TREE (t2
));
439 /* Main worker for gimple_register_canonical_type. */
442 gimple_register_canonical_type_1 (tree t
, hashval_t hash
)
446 gcc_checking_assert (TYPE_P (t
) && !TYPE_CANONICAL (t
)
447 && type_with_alias_set_p (t
)
448 && canonical_type_used_p (t
));
450 slot
= htab_find_slot_with_hash (gimple_canonical_types
, t
, hash
, INSERT
);
453 tree new_type
= (tree
)(*slot
);
454 gcc_checking_assert (new_type
!= t
);
455 TYPE_CANONICAL (t
) = new_type
;
459 TYPE_CANONICAL (t
) = t
;
461 /* Cache the just computed hash value. */
462 num_canonical_type_hash_entries
++;
463 bool existed_p
= canonical_type_hash_cache
->put (t
, hash
);
464 gcc_assert (!existed_p
);
468 /* Register type T in the global type table gimple_types and set
469 TYPE_CANONICAL of T accordingly.
470 This is used by LTO to merge structurally equivalent types for
471 type-based aliasing purposes across different TUs and languages.
473 ??? This merging does not exactly match how the tree.c middle-end
474 functions will assign TYPE_CANONICAL when new types are created
475 during optimization (which at least happens for pointer and array
479 gimple_register_canonical_type (tree t
)
481 if (TYPE_CANONICAL (t
) || !type_with_alias_set_p (t
)
482 || !canonical_type_used_p (t
))
485 /* Canonical types are same among all complete variants. */
486 if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (t
)))
487 TYPE_CANONICAL (t
) = TYPE_CANONICAL (TYPE_MAIN_VARIANT (t
));
490 gimple_register_canonical_type_1 (TYPE_MAIN_VARIANT (t
),
491 hash_canonical_type (TYPE_MAIN_VARIANT (t
)));
492 TYPE_CANONICAL (t
) = TYPE_CANONICAL (TYPE_MAIN_VARIANT (t
));
496 /* Re-compute TYPE_CANONICAL for NODE and related types. */
499 lto_register_canonical_types (tree node
, bool first_p
)
506 TYPE_CANONICAL (node
) = NULL_TREE
;
508 if (POINTER_TYPE_P (node
)
509 || TREE_CODE (node
) == COMPLEX_TYPE
510 || TREE_CODE (node
) == ARRAY_TYPE
)
511 lto_register_canonical_types (TREE_TYPE (node
), first_p
);
514 gimple_register_canonical_type (node
);
518 /* Remember trees that contains references to declarations. */
519 static GTY(()) vec
<tree
, va_gc
> *tree_with_vars
;
521 #define CHECK_VAR(tt) \
524 if ((tt) && VAR_OR_FUNCTION_DECL_P (tt) \
525 && (TREE_PUBLIC (tt) || DECL_EXTERNAL (tt))) \
529 #define CHECK_NO_VAR(tt) \
530 gcc_checking_assert (!(tt) || !VAR_OR_FUNCTION_DECL_P (tt))
532 /* Check presence of pointers to decls in fields of a tree_typed T. */
535 mentions_vars_p_typed (tree t
)
537 CHECK_NO_VAR (TREE_TYPE (t
));
541 /* Check presence of pointers to decls in fields of a tree_common T. */
544 mentions_vars_p_common (tree t
)
546 if (mentions_vars_p_typed (t
))
548 CHECK_NO_VAR (TREE_CHAIN (t
));
552 /* Check presence of pointers to decls in fields of a decl_minimal T. */
555 mentions_vars_p_decl_minimal (tree t
)
557 if (mentions_vars_p_common (t
))
559 CHECK_NO_VAR (DECL_NAME (t
));
560 CHECK_VAR (DECL_CONTEXT (t
));
564 /* Check presence of pointers to decls in fields of a decl_common T. */
567 mentions_vars_p_decl_common (tree t
)
569 if (mentions_vars_p_decl_minimal (t
))
571 CHECK_VAR (DECL_SIZE (t
));
572 CHECK_VAR (DECL_SIZE_UNIT (t
));
573 CHECK_VAR (DECL_INITIAL (t
));
574 CHECK_NO_VAR (DECL_ATTRIBUTES (t
));
575 CHECK_VAR (DECL_ABSTRACT_ORIGIN (t
));
579 /* Check presence of pointers to decls in fields of a decl_with_vis T. */
582 mentions_vars_p_decl_with_vis (tree t
)
584 if (mentions_vars_p_decl_common (t
))
587 /* Accessor macro has side-effects, use field-name here. */
588 CHECK_NO_VAR (t
->decl_with_vis
.assembler_name
);
592 /* Check presence of pointers to decls in fields of a decl_non_common T. */
595 mentions_vars_p_decl_non_common (tree t
)
597 if (mentions_vars_p_decl_with_vis (t
))
599 CHECK_NO_VAR (DECL_RESULT_FLD (t
));
603 /* Check presence of pointers to decls in fields of a decl_non_common T. */
606 mentions_vars_p_function (tree t
)
608 if (mentions_vars_p_decl_non_common (t
))
610 CHECK_NO_VAR (DECL_ARGUMENTS (t
));
611 CHECK_NO_VAR (DECL_VINDEX (t
));
612 CHECK_VAR (DECL_FUNCTION_PERSONALITY (t
));
616 /* Check presence of pointers to decls in fields of a field_decl T. */
619 mentions_vars_p_field_decl (tree t
)
621 if (mentions_vars_p_decl_common (t
))
623 CHECK_VAR (DECL_FIELD_OFFSET (t
));
624 CHECK_NO_VAR (DECL_BIT_FIELD_TYPE (t
));
625 CHECK_NO_VAR (DECL_QUALIFIER (t
));
626 CHECK_NO_VAR (DECL_FIELD_BIT_OFFSET (t
));
627 CHECK_NO_VAR (DECL_FCONTEXT (t
));
631 /* Check presence of pointers to decls in fields of a type T. */
634 mentions_vars_p_type (tree t
)
636 if (mentions_vars_p_common (t
))
638 CHECK_NO_VAR (TYPE_CACHED_VALUES (t
));
639 CHECK_VAR (TYPE_SIZE (t
));
640 CHECK_VAR (TYPE_SIZE_UNIT (t
));
641 CHECK_NO_VAR (TYPE_ATTRIBUTES (t
));
642 CHECK_NO_VAR (TYPE_NAME (t
));
644 CHECK_VAR (TYPE_MINVAL (t
));
645 CHECK_VAR (TYPE_MAXVAL (t
));
647 /* Accessor is for derived node types only. */
648 CHECK_NO_VAR (t
->type_non_common
.binfo
);
650 CHECK_VAR (TYPE_CONTEXT (t
));
651 CHECK_NO_VAR (TYPE_CANONICAL (t
));
652 CHECK_NO_VAR (TYPE_MAIN_VARIANT (t
));
653 CHECK_NO_VAR (TYPE_NEXT_VARIANT (t
));
657 /* Check presence of pointers to decls in fields of a BINFO T. */
660 mentions_vars_p_binfo (tree t
)
662 unsigned HOST_WIDE_INT i
, n
;
664 if (mentions_vars_p_common (t
))
666 CHECK_VAR (BINFO_VTABLE (t
));
667 CHECK_NO_VAR (BINFO_OFFSET (t
));
668 CHECK_NO_VAR (BINFO_VIRTUALS (t
));
669 CHECK_NO_VAR (BINFO_VPTR_FIELD (t
));
670 n
= vec_safe_length (BINFO_BASE_ACCESSES (t
));
671 for (i
= 0; i
< n
; i
++)
672 CHECK_NO_VAR (BINFO_BASE_ACCESS (t
, i
));
673 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
674 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
675 n
= BINFO_N_BASE_BINFOS (t
);
676 for (i
= 0; i
< n
; i
++)
677 CHECK_NO_VAR (BINFO_BASE_BINFO (t
, i
));
681 /* Check presence of pointers to decls in fields of a CONSTRUCTOR T. */
684 mentions_vars_p_constructor (tree t
)
686 unsigned HOST_WIDE_INT idx
;
689 if (mentions_vars_p_typed (t
))
692 for (idx
= 0; vec_safe_iterate (CONSTRUCTOR_ELTS (t
), idx
, &ce
); idx
++)
694 CHECK_NO_VAR (ce
->index
);
695 CHECK_VAR (ce
->value
);
700 /* Check presence of pointers to decls in fields of an expression tree T. */
703 mentions_vars_p_expr (tree t
)
706 if (mentions_vars_p_typed (t
))
708 for (i
= TREE_OPERAND_LENGTH (t
) - 1; i
>= 0; --i
)
709 CHECK_VAR (TREE_OPERAND (t
, i
));
713 /* Check presence of pointers to decls in fields of an OMP_CLAUSE T. */
716 mentions_vars_p_omp_clause (tree t
)
719 if (mentions_vars_p_common (t
))
721 for (i
= omp_clause_num_ops
[OMP_CLAUSE_CODE (t
)] - 1; i
>= 0; --i
)
722 CHECK_VAR (OMP_CLAUSE_OPERAND (t
, i
));
726 /* Check presence of pointers to decls that needs later fixup in T. */
729 mentions_vars_p (tree t
)
731 switch (TREE_CODE (t
))
733 case IDENTIFIER_NODE
:
737 CHECK_VAR (TREE_VALUE (t
));
738 CHECK_VAR (TREE_PURPOSE (t
));
739 CHECK_NO_VAR (TREE_CHAIN (t
));
743 return mentions_vars_p_field_decl (t
);
752 return mentions_vars_p_decl_common (t
);
755 return mentions_vars_p_decl_with_vis (t
);
758 return mentions_vars_p_decl_non_common (t
);
761 return mentions_vars_p_function (t
);
764 return mentions_vars_p_binfo (t
);
766 case PLACEHOLDER_EXPR
:
767 return mentions_vars_p_common (t
);
770 case TRANSLATION_UNIT_DECL
:
771 case OPTIMIZATION_NODE
:
772 case TARGET_OPTION_NODE
:
776 return mentions_vars_p_constructor (t
);
779 return mentions_vars_p_omp_clause (t
);
784 if (mentions_vars_p_type (t
))
789 if (mentions_vars_p_expr (t
))
792 else if (CONSTANT_CLASS_P (t
))
793 CHECK_NO_VAR (TREE_TYPE (t
));
801 /* Return the resolution for the decl with index INDEX from DATA_IN. */
803 static enum ld_plugin_symbol_resolution
804 get_resolution (struct data_in
*data_in
, unsigned index
)
806 if (data_in
->globals_resolution
.exists ())
808 ld_plugin_symbol_resolution_t ret
;
809 /* We can have references to not emitted functions in
810 DECL_FUNCTION_PERSONALITY at least. So we can and have
811 to indeed return LDPR_UNKNOWN in some cases. */
812 if (data_in
->globals_resolution
.length () <= index
)
814 ret
= data_in
->globals_resolution
[index
];
818 /* Delay resolution finding until decl merging. */
822 /* We need to record resolutions until symbol table is read. */
824 register_resolution (struct lto_file_decl_data
*file_data
, tree decl
,
825 enum ld_plugin_symbol_resolution resolution
)
827 if (resolution
== LDPR_UNKNOWN
)
829 if (!file_data
->resolution_map
)
830 file_data
->resolution_map
831 = new hash_map
<tree
, ld_plugin_symbol_resolution
>;
832 file_data
->resolution_map
->put (decl
, resolution
);
835 /* Register DECL with the global symbol table and change its
836 name if necessary to avoid name clashes for static globals across
840 lto_register_var_decl_in_symtab (struct data_in
*data_in
, tree decl
,
845 /* Variable has file scope, not local. */
846 if (!TREE_PUBLIC (decl
)
847 && !((context
= decl_function_context (decl
))
848 && auto_var_in_fn_p (decl
, context
)))
849 rest_of_decl_compilation (decl
, 1, 0);
851 /* If this variable has already been declared, queue the
852 declaration for merging. */
853 if (TREE_PUBLIC (decl
))
854 register_resolution (data_in
->file_data
,
855 decl
, get_resolution (data_in
, ix
));
859 /* Register DECL with the global symbol table and change its
860 name if necessary to avoid name clashes for static globals across
861 different files. DATA_IN contains descriptors and tables for the
865 lto_register_function_decl_in_symtab (struct data_in
*data_in
, tree decl
,
868 /* If this variable has already been declared, queue the
869 declaration for merging. */
870 if (TREE_PUBLIC (decl
) && !DECL_ABSTRACT_P (decl
))
871 register_resolution (data_in
->file_data
,
872 decl
, get_resolution (data_in
, ix
));
876 /* For the type T re-materialize it in the type variant list and
877 the pointer/reference-to chains. */
880 lto_fixup_prevailing_type (tree t
)
882 /* The following re-creates proper variant lists while fixing up
883 the variant leaders. We do not stream TYPE_NEXT_VARIANT so the
884 variant list state before fixup is broken. */
886 /* If we are not our own variant leader link us into our new leaders
888 if (TYPE_MAIN_VARIANT (t
) != t
)
890 tree mv
= TYPE_MAIN_VARIANT (t
);
891 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (mv
);
892 TYPE_NEXT_VARIANT (mv
) = t
;
895 /* The following reconstructs the pointer chains
896 of the new pointed-to type if we are a main variant. We do
897 not stream those so they are broken before fixup. */
898 if (TREE_CODE (t
) == POINTER_TYPE
899 && TYPE_MAIN_VARIANT (t
) == t
)
901 TYPE_NEXT_PTR_TO (t
) = TYPE_POINTER_TO (TREE_TYPE (t
));
902 TYPE_POINTER_TO (TREE_TYPE (t
)) = t
;
904 else if (TREE_CODE (t
) == REFERENCE_TYPE
905 && TYPE_MAIN_VARIANT (t
) == t
)
907 TYPE_NEXT_REF_TO (t
) = TYPE_REFERENCE_TO (TREE_TYPE (t
));
908 TYPE_REFERENCE_TO (TREE_TYPE (t
)) = t
;
913 /* We keep prevailing tree SCCs in a hashtable with manual collision
914 handling (in case all hashes compare the same) and keep the colliding
915 entries in the tree_scc->next chain. */
920 /* Hash of the whole SCC. */
922 /* Number of trees in the SCC. */
924 /* Number of possible entries into the SCC (tree nodes [0..entry_len-1]
925 which share the same individual tree hash). */
927 /* The members of the SCC.
928 We only need to remember the first entry node candidate for prevailing
929 SCCs (but of course have access to all entries for SCCs we are
931 ??? For prevailing SCCs we really only need hash and the first
932 entry candidate, but that's too awkward to implement. */
936 struct tree_scc_hasher
: nofree_ptr_hash
<tree_scc
>
938 static inline hashval_t
hash (const tree_scc
*);
939 static inline bool equal (const tree_scc
*, const tree_scc
*);
943 tree_scc_hasher::hash (const tree_scc
*scc
)
949 tree_scc_hasher::equal (const tree_scc
*scc1
, const tree_scc
*scc2
)
951 if (scc1
->hash
!= scc2
->hash
952 || scc1
->len
!= scc2
->len
953 || scc1
->entry_len
!= scc2
->entry_len
)
958 static hash_table
<tree_scc_hasher
> *tree_scc_hash
;
959 static struct obstack tree_scc_hash_obstack
;
961 static unsigned long num_merged_types
;
962 static unsigned long num_prevailing_types
;
963 static unsigned long num_type_scc_trees
;
964 static unsigned long total_scc_size
;
965 static unsigned long num_sccs_read
;
966 static unsigned long total_scc_size_merged
;
967 static unsigned long num_sccs_merged
;
968 static unsigned long num_scc_compares
;
969 static unsigned long num_scc_compare_collisions
;
972 /* Compare the two entries T1 and T2 of two SCCs that are possibly equal,
973 recursing through in-SCC tree edges. Returns true if the SCCs entered
974 through T1 and T2 are equal and fills in *MAP with the pairs of
975 SCC entries we visited, starting with (*MAP)[0] = T1 and (*MAP)[1] = T2. */
978 compare_tree_sccs_1 (tree t1
, tree t2
, tree
**map
)
982 /* Mark already visited nodes. */
983 TREE_ASM_WRITTEN (t2
) = 1;
985 /* Push the pair onto map. */
990 /* Compare value-fields. */
991 #define compare_values(X) \
993 if (X(t1) != X(t2)) \
997 compare_values (TREE_CODE
);
998 code
= TREE_CODE (t1
);
1002 compare_values (TREE_SIDE_EFFECTS
);
1003 compare_values (TREE_CONSTANT
);
1004 compare_values (TREE_READONLY
);
1005 compare_values (TREE_PUBLIC
);
1007 compare_values (TREE_ADDRESSABLE
);
1008 compare_values (TREE_THIS_VOLATILE
);
1010 compare_values (DECL_UNSIGNED
);
1011 else if (TYPE_P (t1
))
1012 compare_values (TYPE_UNSIGNED
);
1014 compare_values (TYPE_ARTIFICIAL
);
1016 compare_values (TREE_NO_WARNING
);
1017 compare_values (TREE_NOTHROW
);
1018 compare_values (TREE_STATIC
);
1019 if (code
!= TREE_BINFO
)
1020 compare_values (TREE_PRIVATE
);
1021 compare_values (TREE_PROTECTED
);
1022 compare_values (TREE_DEPRECATED
);
1025 if (AGGREGATE_TYPE_P (t1
))
1026 compare_values (TYPE_REVERSE_STORAGE_ORDER
);
1028 compare_values (TYPE_SATURATING
);
1029 compare_values (TYPE_ADDR_SPACE
);
1031 else if (code
== SSA_NAME
)
1032 compare_values (SSA_NAME_IS_DEFAULT_DEF
);
1034 if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
1036 if (!wi::eq_p (t1
, t2
))
1040 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
1042 /* ??? No suitable compare routine available. */
1043 REAL_VALUE_TYPE r1
= TREE_REAL_CST (t1
);
1044 REAL_VALUE_TYPE r2
= TREE_REAL_CST (t2
);
1046 || r1
.decimal
!= r2
.decimal
1047 || r1
.sign
!= r2
.sign
1048 || r1
.signalling
!= r2
.signalling
1049 || r1
.canonical
!= r2
.canonical
1050 || r1
.uexp
!= r2
.uexp
)
1052 for (unsigned i
= 0; i
< SIGSZ
; ++i
)
1053 if (r1
.sig
[i
] != r2
.sig
[i
])
1057 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
1058 if (!fixed_compare (EQ_EXPR
,
1059 TREE_FIXED_CST_PTR (t1
), TREE_FIXED_CST_PTR (t2
)))
1063 /* We want to compare locations up to the point where it makes
1064 a difference for streaming - thus whether the decl is builtin or not. */
1065 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
1066 compare_values (streamer_handle_as_builtin_p
);
1068 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1070 compare_values (DECL_MODE
);
1071 compare_values (DECL_NONLOCAL
);
1072 compare_values (DECL_VIRTUAL_P
);
1073 compare_values (DECL_IGNORED_P
);
1074 compare_values (DECL_ABSTRACT_P
);
1075 compare_values (DECL_ARTIFICIAL
);
1076 compare_values (DECL_USER_ALIGN
);
1077 compare_values (DECL_PRESERVE_P
);
1078 compare_values (DECL_EXTERNAL
);
1079 compare_values (DECL_GIMPLE_REG_P
);
1080 compare_values (DECL_ALIGN
);
1081 if (code
== LABEL_DECL
)
1083 compare_values (EH_LANDING_PAD_NR
);
1084 compare_values (LABEL_DECL_UID
);
1086 else if (code
== FIELD_DECL
)
1088 compare_values (DECL_PACKED
);
1089 compare_values (DECL_NONADDRESSABLE_P
);
1090 compare_values (DECL_OFFSET_ALIGN
);
1092 else if (code
== VAR_DECL
)
1094 compare_values (DECL_HAS_DEBUG_EXPR_P
);
1095 compare_values (DECL_NONLOCAL_FRAME
);
1097 if (code
== RESULT_DECL
1098 || code
== PARM_DECL
1099 || code
== VAR_DECL
)
1101 compare_values (DECL_BY_REFERENCE
);
1102 if (code
== VAR_DECL
1103 || code
== PARM_DECL
)
1104 compare_values (DECL_HAS_VALUE_EXPR_P
);
1108 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
1109 compare_values (DECL_REGISTER
);
1111 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1113 compare_values (DECL_COMMON
);
1114 compare_values (DECL_DLLIMPORT_P
);
1115 compare_values (DECL_WEAK
);
1116 compare_values (DECL_SEEN_IN_BIND_EXPR_P
);
1117 compare_values (DECL_COMDAT
);
1118 compare_values (DECL_VISIBILITY
);
1119 compare_values (DECL_VISIBILITY_SPECIFIED
);
1120 if (code
== VAR_DECL
)
1122 compare_values (DECL_HARD_REGISTER
);
1123 /* DECL_IN_TEXT_SECTION is set during final asm output only. */
1124 compare_values (DECL_IN_CONSTANT_POOL
);
1128 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1130 compare_values (DECL_BUILT_IN_CLASS
);
1131 compare_values (DECL_STATIC_CONSTRUCTOR
);
1132 compare_values (DECL_STATIC_DESTRUCTOR
);
1133 compare_values (DECL_UNINLINABLE
);
1134 compare_values (DECL_POSSIBLY_INLINED
);
1135 compare_values (DECL_IS_NOVOPS
);
1136 compare_values (DECL_IS_RETURNS_TWICE
);
1137 compare_values (DECL_IS_MALLOC
);
1138 compare_values (DECL_IS_OPERATOR_NEW
);
1139 compare_values (DECL_DECLARED_INLINE_P
);
1140 compare_values (DECL_STATIC_CHAIN
);
1141 compare_values (DECL_NO_INLINE_WARNING_P
);
1142 compare_values (DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT
);
1143 compare_values (DECL_NO_LIMIT_STACK
);
1144 compare_values (DECL_DISREGARD_INLINE_LIMITS
);
1145 compare_values (DECL_PURE_P
);
1146 compare_values (DECL_LOOPING_CONST_OR_PURE_P
);
1147 compare_values (DECL_FINAL_P
);
1148 compare_values (DECL_CXX_CONSTRUCTOR_P
);
1149 compare_values (DECL_CXX_DESTRUCTOR_P
);
1150 if (DECL_BUILT_IN_CLASS (t1
) != NOT_BUILT_IN
)
1151 compare_values (DECL_FUNCTION_CODE
);
1154 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
1156 compare_values (TYPE_MODE
);
1157 compare_values (TYPE_STRING_FLAG
);
1158 compare_values (TYPE_NEEDS_CONSTRUCTING
);
1159 if (RECORD_OR_UNION_TYPE_P (t1
))
1161 compare_values (TYPE_TRANSPARENT_AGGR
);
1162 compare_values (TYPE_FINAL_P
);
1164 else if (code
== ARRAY_TYPE
)
1165 compare_values (TYPE_NONALIASED_COMPONENT
);
1166 compare_values (TYPE_PACKED
);
1167 compare_values (TYPE_RESTRICT
);
1168 compare_values (TYPE_USER_ALIGN
);
1169 compare_values (TYPE_READONLY
);
1170 compare_values (TYPE_PRECISION
);
1171 compare_values (TYPE_ALIGN
);
1172 /* Do not compare TYPE_ALIAS_SET. Doing so introduce ordering issues
1173 with calls to get_alias_set which may initialize it for streamed
1177 /* We don't want to compare locations, so there is nothing do compare
1180 /* BLOCKs are function local and we don't merge anything there, so
1181 simply refuse to merge. */
1182 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
1185 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
1186 if (strcmp (TRANSLATION_UNIT_LANGUAGE (t1
),
1187 TRANSLATION_UNIT_LANGUAGE (t2
)) != 0)
1190 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
))
1191 if (!cl_target_option_eq (TREE_TARGET_OPTION (t1
), TREE_TARGET_OPTION (t2
)))
1194 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
1195 if (memcmp (TREE_OPTIMIZATION (t1
), TREE_OPTIMIZATION (t2
),
1196 sizeof (struct cl_optimization
)) != 0)
1199 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1200 if (vec_safe_length (BINFO_BASE_ACCESSES (t1
))
1201 != vec_safe_length (BINFO_BASE_ACCESSES (t2
)))
1204 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1205 compare_values (CONSTRUCTOR_NELTS
);
1207 if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
1208 if (IDENTIFIER_LENGTH (t1
) != IDENTIFIER_LENGTH (t2
)
1209 || memcmp (IDENTIFIER_POINTER (t1
), IDENTIFIER_POINTER (t2
),
1210 IDENTIFIER_LENGTH (t1
)) != 0)
1213 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
1214 if (TREE_STRING_LENGTH (t1
) != TREE_STRING_LENGTH (t2
)
1215 || memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
1216 TREE_STRING_LENGTH (t1
)) != 0)
1219 if (code
== OMP_CLAUSE
)
1221 compare_values (OMP_CLAUSE_CODE
);
1222 switch (OMP_CLAUSE_CODE (t1
))
1224 case OMP_CLAUSE_DEFAULT
:
1225 compare_values (OMP_CLAUSE_DEFAULT_KIND
);
1227 case OMP_CLAUSE_SCHEDULE
:
1228 compare_values (OMP_CLAUSE_SCHEDULE_KIND
);
1230 case OMP_CLAUSE_DEPEND
:
1231 compare_values (OMP_CLAUSE_DEPEND_KIND
);
1233 case OMP_CLAUSE_MAP
:
1234 compare_values (OMP_CLAUSE_MAP_KIND
);
1236 case OMP_CLAUSE_PROC_BIND
:
1237 compare_values (OMP_CLAUSE_PROC_BIND_KIND
);
1239 case OMP_CLAUSE_REDUCTION
:
1240 compare_values (OMP_CLAUSE_REDUCTION_CODE
);
1241 compare_values (OMP_CLAUSE_REDUCTION_GIMPLE_INIT
);
1242 compare_values (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE
);
1249 #undef compare_values
1252 /* Compare pointer fields. */
1254 /* Recurse. Search & Replaced from DFS_write_tree_body.
1255 Folding the early checks into the compare_tree_edges recursion
1256 macro makes debugging way quicker as you are able to break on
1257 compare_tree_sccs_1 and simply finish until a call returns false
1258 to spot the SCC members with the difference. */
1259 #define compare_tree_edges(E1, E2) \
1261 tree t1_ = (E1), t2_ = (E2); \
1264 || !TREE_VISITED (t2_) \
1265 || (!TREE_ASM_WRITTEN (t2_) \
1266 && !compare_tree_sccs_1 (t1_, t2_, map)))) \
1268 /* Only non-NULL trees outside of the SCC may compare equal. */ \
1269 gcc_checking_assert (t1_ != t2_ || (!t2_ || !TREE_VISITED (t2_))); \
1272 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
1274 if (code
!= IDENTIFIER_NODE
)
1275 compare_tree_edges (TREE_TYPE (t1
), TREE_TYPE (t2
));
1278 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
1281 /* Note that the number of elements for EXPR has already been emitted
1282 in EXPR's header (see streamer_write_tree_header). */
1283 for (i
= 0; i
< VECTOR_CST_NELTS (t1
); ++i
)
1284 compare_tree_edges (VECTOR_CST_ELT (t1
, i
), VECTOR_CST_ELT (t2
, i
));
1287 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
1289 compare_tree_edges (TREE_REALPART (t1
), TREE_REALPART (t2
));
1290 compare_tree_edges (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
1293 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
1295 compare_tree_edges (DECL_NAME (t1
), DECL_NAME (t2
));
1296 /* ??? Global decls from different TUs have non-matching
1297 TRANSLATION_UNIT_DECLs. Only consider a small set of
1298 decls equivalent, we should not end up merging others. */
1299 if ((code
== TYPE_DECL
1300 || code
== NAMESPACE_DECL
1301 || code
== IMPORTED_DECL
1302 || code
== CONST_DECL
1303 || (VAR_OR_FUNCTION_DECL_P (t1
)
1304 && (TREE_PUBLIC (t1
) || DECL_EXTERNAL (t1
))))
1305 && DECL_FILE_SCOPE_P (t1
) && DECL_FILE_SCOPE_P (t2
))
1308 compare_tree_edges (DECL_CONTEXT (t1
), DECL_CONTEXT (t2
));
1311 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1313 compare_tree_edges (DECL_SIZE (t1
), DECL_SIZE (t2
));
1314 compare_tree_edges (DECL_SIZE_UNIT (t1
), DECL_SIZE_UNIT (t2
));
1315 compare_tree_edges (DECL_ATTRIBUTES (t1
), DECL_ATTRIBUTES (t2
));
1316 compare_tree_edges (DECL_ABSTRACT_ORIGIN (t1
), DECL_ABSTRACT_ORIGIN (t2
));
1317 if ((code
== VAR_DECL
1318 || code
== PARM_DECL
)
1319 && DECL_HAS_VALUE_EXPR_P (t1
))
1320 compare_tree_edges (DECL_VALUE_EXPR (t1
), DECL_VALUE_EXPR (t2
));
1321 if (code
== VAR_DECL
1322 && DECL_HAS_DEBUG_EXPR_P (t1
))
1323 compare_tree_edges (DECL_DEBUG_EXPR (t1
), DECL_DEBUG_EXPR (t2
));
1324 /* LTO specific edges. */
1325 if (code
!= FUNCTION_DECL
1326 && code
!= TRANSLATION_UNIT_DECL
)
1327 compare_tree_edges (DECL_INITIAL (t1
), DECL_INITIAL (t2
));
1330 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
1332 if (code
== FUNCTION_DECL
)
1335 for (a1
= DECL_ARGUMENTS (t1
), a2
= DECL_ARGUMENTS (t2
);
1337 a1
= TREE_CHAIN (a1
), a2
= TREE_CHAIN (a2
))
1338 compare_tree_edges (a1
, a2
);
1339 compare_tree_edges (DECL_RESULT (t1
), DECL_RESULT (t2
));
1341 else if (code
== TYPE_DECL
)
1342 compare_tree_edges (DECL_ORIGINAL_TYPE (t1
), DECL_ORIGINAL_TYPE (t2
));
1345 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1347 /* Make sure we don't inadvertently set the assembler name. */
1348 if (DECL_ASSEMBLER_NAME_SET_P (t1
))
1349 compare_tree_edges (DECL_ASSEMBLER_NAME (t1
),
1350 DECL_ASSEMBLER_NAME (t2
));
1353 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
1355 compare_tree_edges (DECL_FIELD_OFFSET (t1
), DECL_FIELD_OFFSET (t2
));
1356 compare_tree_edges (DECL_BIT_FIELD_TYPE (t1
), DECL_BIT_FIELD_TYPE (t2
));
1357 compare_tree_edges (DECL_BIT_FIELD_REPRESENTATIVE (t1
),
1358 DECL_BIT_FIELD_REPRESENTATIVE (t2
));
1359 compare_tree_edges (DECL_FIELD_BIT_OFFSET (t1
),
1360 DECL_FIELD_BIT_OFFSET (t2
));
1361 compare_tree_edges (DECL_FCONTEXT (t1
), DECL_FCONTEXT (t2
));
1364 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1366 compare_tree_edges (DECL_FUNCTION_PERSONALITY (t1
),
1367 DECL_FUNCTION_PERSONALITY (t2
));
1368 compare_tree_edges (DECL_VINDEX (t1
), DECL_VINDEX (t2
));
1369 compare_tree_edges (DECL_FUNCTION_SPECIFIC_TARGET (t1
),
1370 DECL_FUNCTION_SPECIFIC_TARGET (t2
));
1371 compare_tree_edges (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t1
),
1372 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t2
));
1375 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
1377 compare_tree_edges (TYPE_SIZE (t1
), TYPE_SIZE (t2
));
1378 compare_tree_edges (TYPE_SIZE_UNIT (t1
), TYPE_SIZE_UNIT (t2
));
1379 compare_tree_edges (TYPE_ATTRIBUTES (t1
), TYPE_ATTRIBUTES (t2
));
1380 compare_tree_edges (TYPE_NAME (t1
), TYPE_NAME (t2
));
1381 /* Do not compare TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
1382 reconstructed during fixup. */
1383 /* Do not compare TYPE_NEXT_VARIANT, we reconstruct the variant lists
1385 compare_tree_edges (TYPE_MAIN_VARIANT (t1
), TYPE_MAIN_VARIANT (t2
));
1386 /* ??? Global types from different TUs have non-matching
1387 TRANSLATION_UNIT_DECLs. Still merge them if they are otherwise
1389 if (TYPE_FILE_SCOPE_P (t1
) && TYPE_FILE_SCOPE_P (t2
))
1392 compare_tree_edges (TYPE_CONTEXT (t1
), TYPE_CONTEXT (t2
));
1393 /* TYPE_CANONICAL is re-computed during type merging, so do not
1395 compare_tree_edges (TYPE_STUB_DECL (t1
), TYPE_STUB_DECL (t2
));
1398 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
1400 if (code
== ENUMERAL_TYPE
)
1401 compare_tree_edges (TYPE_VALUES (t1
), TYPE_VALUES (t2
));
1402 else if (code
== ARRAY_TYPE
)
1403 compare_tree_edges (TYPE_DOMAIN (t1
), TYPE_DOMAIN (t2
));
1404 else if (RECORD_OR_UNION_TYPE_P (t1
))
1407 for (f1
= TYPE_FIELDS (t1
), f2
= TYPE_FIELDS (t2
);
1409 f1
= TREE_CHAIN (f1
), f2
= TREE_CHAIN (f2
))
1410 compare_tree_edges (f1
, f2
);
1411 compare_tree_edges (TYPE_BINFO (t1
), TYPE_BINFO (t2
));
1413 else if (code
== FUNCTION_TYPE
1414 || code
== METHOD_TYPE
)
1415 compare_tree_edges (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
));
1416 if (!POINTER_TYPE_P (t1
))
1417 compare_tree_edges (TYPE_MINVAL (t1
), TYPE_MINVAL (t2
));
1418 compare_tree_edges (TYPE_MAXVAL (t1
), TYPE_MAXVAL (t2
));
1421 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
1423 compare_tree_edges (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
));
1424 compare_tree_edges (TREE_VALUE (t1
), TREE_VALUE (t2
));
1425 compare_tree_edges (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
1428 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1429 for (int i
= 0; i
< TREE_VEC_LENGTH (t1
); i
++)
1430 compare_tree_edges (TREE_VEC_ELT (t1
, i
), TREE_VEC_ELT (t2
, i
));
1432 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
1434 for (int i
= 0; i
< TREE_OPERAND_LENGTH (t1
); i
++)
1435 compare_tree_edges (TREE_OPERAND (t1
, i
),
1436 TREE_OPERAND (t2
, i
));
1438 /* BLOCKs are function local and we don't merge anything there. */
1439 if (TREE_BLOCK (t1
) || TREE_BLOCK (t2
))
1443 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1447 /* Lengths have already been compared above. */
1448 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (t1
), i
, t
)
1449 compare_tree_edges (t
, BINFO_BASE_BINFO (t2
, i
));
1450 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (t1
), i
, t
)
1451 compare_tree_edges (t
, BINFO_BASE_ACCESS (t2
, i
));
1452 compare_tree_edges (BINFO_OFFSET (t1
), BINFO_OFFSET (t2
));
1453 compare_tree_edges (BINFO_VTABLE (t1
), BINFO_VTABLE (t2
));
1454 compare_tree_edges (BINFO_VPTR_FIELD (t1
), BINFO_VPTR_FIELD (t2
));
1455 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
1456 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
1459 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1463 /* Lengths have already been compared above. */
1464 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, index
, value
)
1466 compare_tree_edges (index
, CONSTRUCTOR_ELT (t2
, i
)->index
);
1467 compare_tree_edges (value
, CONSTRUCTOR_ELT (t2
, i
)->value
);
1471 if (code
== OMP_CLAUSE
)
1475 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (t1
)]; i
++)
1476 compare_tree_edges (OMP_CLAUSE_OPERAND (t1
, i
),
1477 OMP_CLAUSE_OPERAND (t2
, i
));
1478 compare_tree_edges (OMP_CLAUSE_CHAIN (t1
), OMP_CLAUSE_CHAIN (t2
));
1481 #undef compare_tree_edges
1486 /* Compare the tree scc SCC to the prevailing candidate PSCC, filling
1487 out MAP if they are equal. */
1490 compare_tree_sccs (tree_scc
*pscc
, tree_scc
*scc
,
1493 /* Assume SCC entry hashes are sorted after their cardinality. Which
1494 means we can simply take the first n-tuple of equal hashes
1495 (which is recorded as entry_len) and do n SCC entry candidate
1497 for (unsigned i
= 0; i
< pscc
->entry_len
; ++i
)
1500 num_scc_compare_collisions
++;
1501 if (compare_tree_sccs_1 (pscc
->entries
[0], scc
->entries
[i
], &mapp
))
1503 /* Equal - no need to reset TREE_VISITED or TREE_ASM_WRITTEN
1504 on the scc as all trees will be freed. */
1507 /* Reset TREE_ASM_WRITTEN on scc for the next compare or in case
1508 the SCC prevails. */
1509 for (unsigned j
= 0; j
< scc
->len
; ++j
)
1510 TREE_ASM_WRITTEN (scc
->entries
[j
]) = 0;
1516 /* QSort sort function to sort a map of two pointers after the 2nd
1520 cmp_tree (const void *p1_
, const void *p2_
)
1522 tree
*p1
= (tree
*)(const_cast<void *>(p1_
));
1523 tree
*p2
= (tree
*)(const_cast<void *>(p2_
));
1526 return ((uintptr_t)p1
[1] < (uintptr_t)p2
[1]) ? -1 : 1;
1529 /* Try to unify the SCC with nodes FROM to FROM + LEN in CACHE and
1530 hash value SCC_HASH with an already recorded SCC. Return true if
1531 that was successful, otherwise return false. */
1534 unify_scc (struct data_in
*data_in
, unsigned from
,
1535 unsigned len
, unsigned scc_entry_len
, hashval_t scc_hash
)
1537 bool unified_p
= false;
1538 struct streamer_tree_cache_d
*cache
= data_in
->reader_cache
;
1540 = (tree_scc
*) alloca (sizeof (tree_scc
) + (len
- 1) * sizeof (tree
));
1542 scc
->hash
= scc_hash
;
1544 scc
->entry_len
= scc_entry_len
;
1545 for (unsigned i
= 0; i
< len
; ++i
)
1547 tree t
= streamer_tree_cache_get_tree (cache
, from
+ i
);
1548 scc
->entries
[i
] = t
;
1549 /* Do not merge SCCs with local entities inside them. Also do
1550 not merge TRANSLATION_UNIT_DECLs. */
1551 if (TREE_CODE (t
) == TRANSLATION_UNIT_DECL
1552 || (VAR_OR_FUNCTION_DECL_P (t
)
1553 && !(TREE_PUBLIC (t
) || DECL_EXTERNAL (t
)))
1554 || TREE_CODE (t
) == LABEL_DECL
)
1556 /* Avoid doing any work for these cases and do not worry to
1557 record the SCCs for further merging. */
1562 /* Look for the list of candidate SCCs to compare against. */
1564 slot
= tree_scc_hash
->find_slot_with_hash (scc
, scc_hash
, INSERT
);
1567 /* Try unifying against each candidate. */
1570 /* Set TREE_VISITED on the scc so we can easily identify tree nodes
1571 outside of the scc when following tree edges. Make sure
1572 that TREE_ASM_WRITTEN is unset so we can use it as 2nd bit
1573 to track whether we visited the SCC member during the compare.
1574 We cannot use TREE_VISITED on the pscc members as the extended
1575 scc and pscc can overlap. */
1576 for (unsigned i
= 0; i
< scc
->len
; ++i
)
1578 TREE_VISITED (scc
->entries
[i
]) = 1;
1579 gcc_checking_assert (!TREE_ASM_WRITTEN (scc
->entries
[i
]));
1582 tree
*map
= XALLOCAVEC (tree
, 2 * len
);
1583 for (tree_scc
*pscc
= *slot
; pscc
; pscc
= pscc
->next
)
1585 if (!compare_tree_sccs (pscc
, scc
, map
))
1588 /* Found an equal SCC. */
1590 num_scc_compare_collisions
--;
1592 total_scc_size_merged
+= len
;
1595 for (unsigned i
= 0; i
< len
; ++i
)
1597 tree t
= map
[2*i
+1];
1598 enum tree_code code
= TREE_CODE (t
);
1599 /* IDENTIFIER_NODEs should be singletons and are merged by the
1600 streamer. The others should be singletons, too, and we
1601 should not merge them in any way. */
1602 gcc_assert (code
!= TRANSLATION_UNIT_DECL
1603 && code
!= IDENTIFIER_NODE
1604 && !streamer_handle_as_builtin_p (t
));
1607 /* Fixup the streamer cache with the prevailing nodes according
1608 to the tree node mapping computed by compare_tree_sccs. */
1610 streamer_tree_cache_replace_tree (cache
, pscc
->entries
[0], from
);
1613 tree
*map2
= XALLOCAVEC (tree
, 2 * len
);
1614 for (unsigned i
= 0; i
< len
; ++i
)
1616 map2
[i
*2] = (tree
)(uintptr_t)(from
+ i
);
1617 map2
[i
*2+1] = scc
->entries
[i
];
1619 qsort (map2
, len
, 2 * sizeof (tree
), cmp_tree
);
1620 qsort (map
, len
, 2 * sizeof (tree
), cmp_tree
);
1621 for (unsigned i
= 0; i
< len
; ++i
)
1622 streamer_tree_cache_replace_tree (cache
, map
[2*i
],
1623 (uintptr_t)map2
[2*i
]);
1626 /* Free the tree nodes from the read SCC. */
1627 data_in
->location_cache
.revert_location_cache ();
1628 for (unsigned i
= 0; i
< len
; ++i
)
1630 if (TYPE_P (scc
->entries
[i
]))
1632 free_node (scc
->entries
[i
]);
1638 /* Reset TREE_VISITED if we didn't unify the SCC with another. */
1640 for (unsigned i
= 0; i
< scc
->len
; ++i
)
1641 TREE_VISITED (scc
->entries
[i
]) = 0;
1644 /* If we didn't unify it to any candidate duplicate the relevant
1645 pieces to permanent storage and link it into the chain. */
1649 = XOBNEWVAR (&tree_scc_hash_obstack
, tree_scc
, sizeof (tree_scc
));
1650 memcpy (pscc
, scc
, sizeof (tree_scc
));
1651 pscc
->next
= (*slot
);
1658 /* Read all the symbols from buffer DATA, using descriptors in DECL_DATA.
1659 RESOLUTIONS is the set of symbols picked by the linker (read from the
1660 resolution file when the linker plugin is being used). */
1663 lto_read_decls (struct lto_file_decl_data
*decl_data
, const void *data
,
1664 vec
<ld_plugin_symbol_resolution_t
> resolutions
)
1666 const struct lto_decl_header
*header
= (const struct lto_decl_header
*) data
;
1667 const int decl_offset
= sizeof (struct lto_decl_header
);
1668 const int main_offset
= decl_offset
+ header
->decl_state_size
;
1669 const int string_offset
= main_offset
+ header
->main_size
;
1670 struct data_in
*data_in
;
1672 const uint32_t *data_ptr
, *data_end
;
1673 uint32_t num_decl_states
;
1675 lto_input_block
ib_main ((const char *) data
+ main_offset
,
1676 header
->main_size
, decl_data
->mode_table
);
1678 data_in
= lto_data_in_create (decl_data
, (const char *) data
+ string_offset
,
1679 header
->string_size
, resolutions
);
1681 /* We do not uniquify the pre-loaded cache entries, those are middle-end
1682 internal types that should not be merged. */
1684 /* Read the global declarations and types. */
1685 while (ib_main
.p
< ib_main
.len
)
1688 unsigned from
= data_in
->reader_cache
->nodes
.length ();
1689 /* Read and uniquify SCCs as in the input stream. */
1690 enum LTO_tags tag
= streamer_read_record_start (&ib_main
);
1691 if (tag
== LTO_tree_scc
)
1694 unsigned scc_entry_len
;
1695 hashval_t scc_hash
= lto_input_scc (&ib_main
, data_in
, &len_
,
1697 unsigned len
= data_in
->reader_cache
->nodes
.length () - from
;
1698 gcc_assert (len
== len_
);
1700 total_scc_size
+= len
;
1703 /* We have the special case of size-1 SCCs that are pre-merged
1704 by means of identifier and string sharing for example.
1705 ??? Maybe we should avoid streaming those as SCCs. */
1706 tree first
= streamer_tree_cache_get_tree (data_in
->reader_cache
,
1709 && (TREE_CODE (first
) == IDENTIFIER_NODE
1710 || TREE_CODE (first
) == INTEGER_CST
1711 || TREE_CODE (first
) == TRANSLATION_UNIT_DECL
1712 || streamer_handle_as_builtin_p (first
)))
1715 /* Try to unify the SCC with already existing ones. */
1717 && unify_scc (data_in
, from
,
1718 len
, scc_entry_len
, scc_hash
))
1721 /* Tree merging failed, mark entries in location cache as
1723 data_in
->location_cache
.accept_location_cache ();
1725 bool seen_type
= false;
1726 for (unsigned i
= 0; i
< len
; ++i
)
1728 tree t
= streamer_tree_cache_get_tree (data_in
->reader_cache
,
1730 /* Reconstruct the type variant and pointer-to/reference-to
1735 num_prevailing_types
++;
1736 lto_fixup_prevailing_type (t
);
1738 /* Compute the canonical type of all types.
1739 ??? Should be able to assert that !TYPE_CANONICAL. */
1740 if (TYPE_P (t
) && !TYPE_CANONICAL (t
))
1742 gimple_register_canonical_type (t
);
1744 register_odr_type (t
);
1746 /* Link shared INTEGER_CSTs into TYPE_CACHED_VALUEs of its
1747 type which is also member of this SCC. */
1748 if (TREE_CODE (t
) == INTEGER_CST
1749 && !TREE_OVERFLOW (t
))
1750 cache_integer_cst (t
);
1751 /* Register TYPE_DECLs with the debuginfo machinery. */
1753 && TREE_CODE (t
) == TYPE_DECL
)
1755 /* Dwarf2out needs location information.
1756 TODO: Moving this out of the streamer loop may noticealy
1757 improve ltrans linemap memory use. */
1758 data_in
->location_cache
.apply_location_cache ();
1759 debug_hooks
->type_decl (t
, !DECL_FILE_SCOPE_P (t
));
1763 /* Register variables and functions with the
1765 if (TREE_CODE (t
) == VAR_DECL
)
1766 lto_register_var_decl_in_symtab (data_in
, t
, from
+ i
);
1767 else if (TREE_CODE (t
) == FUNCTION_DECL
1768 && !DECL_BUILT_IN (t
))
1769 lto_register_function_decl_in_symtab (data_in
, t
, from
+ i
);
1770 /* Scan the tree for references to global functions or
1771 variables and record those for later fixup. */
1772 if (mentions_vars_p (t
))
1773 vec_safe_push (tree_with_vars
, t
);
1777 num_type_scc_trees
+= len
;
1781 /* Pickle stray references. */
1782 t
= lto_input_tree_1 (&ib_main
, data_in
, tag
, 0);
1783 gcc_assert (t
&& data_in
->reader_cache
->nodes
.length () == from
);
1786 data_in
->location_cache
.apply_location_cache ();
1788 /* Read in lto_in_decl_state objects. */
1789 data_ptr
= (const uint32_t *) ((const char*) data
+ decl_offset
);
1791 (const uint32_t *) ((const char*) data_ptr
+ header
->decl_state_size
);
1792 num_decl_states
= *data_ptr
++;
1794 gcc_assert (num_decl_states
> 0);
1795 decl_data
->global_decl_state
= lto_new_in_decl_state ();
1796 data_ptr
= lto_read_in_decl_state (data_in
, data_ptr
,
1797 decl_data
->global_decl_state
);
1799 /* Read in per-function decl states and enter them in hash table. */
1800 decl_data
->function_decl_states
=
1801 hash_table
<decl_state_hasher
>::create_ggc (37);
1803 for (i
= 1; i
< num_decl_states
; i
++)
1805 struct lto_in_decl_state
*state
= lto_new_in_decl_state ();
1807 data_ptr
= lto_read_in_decl_state (data_in
, data_ptr
, state
);
1808 lto_in_decl_state
**slot
1809 = decl_data
->function_decl_states
->find_slot (state
, INSERT
);
1810 gcc_assert (*slot
== NULL
);
1814 if (data_ptr
!= data_end
)
1815 internal_error ("bytecode stream: garbage at the end of symbols section");
1817 /* Set the current decl state to be the global state. */
1818 decl_data
->current_decl_state
= decl_data
->global_decl_state
;
1820 lto_data_in_delete (data_in
);
1823 /* Custom version of strtoll, which is not portable. */
1826 lto_parse_hex (const char *p
)
1830 for (; *p
!= '\0'; ++p
)
1835 if (c
>= '0' && c
<= '9')
1837 else if (c
>= 'a' && c
<= 'f')
1838 part
= c
- 'a' + 10;
1839 else if (c
>= 'A' && c
<= 'F')
1840 part
= c
- 'A' + 10;
1842 internal_error ("could not parse hex number");
1849 /* Read resolution for file named FILE_NAME. The resolution is read from
1853 lto_resolution_read (splay_tree file_ids
, FILE *resolution
, lto_file
*file
)
1855 /* We require that objects in the resolution file are in the same
1856 order as the lto1 command line. */
1857 unsigned int name_len
;
1859 unsigned int num_symbols
;
1861 struct lto_file_decl_data
*file_data
;
1862 splay_tree_node nd
= NULL
;
1867 name_len
= strlen (file
->filename
);
1868 obj_name
= XNEWVEC (char, name_len
+ 1);
1869 fscanf (resolution
, " "); /* Read white space. */
1871 fread (obj_name
, sizeof (char), name_len
, resolution
);
1872 obj_name
[name_len
] = '\0';
1873 if (filename_cmp (obj_name
, file
->filename
) != 0)
1874 internal_error ("unexpected file name %s in linker resolution file. "
1875 "Expected %s", obj_name
, file
->filename
);
1876 if (file
->offset
!= 0)
1881 t
= fscanf (resolution
, "@0x%16s", offset_p
);
1883 internal_error ("could not parse file offset");
1884 offset
= lto_parse_hex (offset_p
);
1885 if (offset
!= file
->offset
)
1886 internal_error ("unexpected offset");
1891 fscanf (resolution
, "%u", &num_symbols
);
1893 for (i
= 0; i
< num_symbols
; i
++)
1897 unsigned HOST_WIDE_INT id
;
1899 enum ld_plugin_symbol_resolution r
= (enum ld_plugin_symbol_resolution
) 0;
1901 unsigned int lto_resolution_str_len
=
1902 sizeof (lto_resolution_str
) / sizeof (char *);
1905 t
= fscanf (resolution
, "%u " HOST_WIDE_INT_PRINT_HEX_PURE
" %26s %*[^\n]\n",
1906 &index
, &id
, r_str
);
1908 internal_error ("invalid line in the resolution file");
1910 for (j
= 0; j
< lto_resolution_str_len
; j
++)
1912 if (strcmp (lto_resolution_str
[j
], r_str
) == 0)
1914 r
= (enum ld_plugin_symbol_resolution
) j
;
1918 if (j
== lto_resolution_str_len
)
1919 internal_error ("invalid resolution in the resolution file");
1921 if (!(nd
&& lto_splay_tree_id_equal_p (nd
->key
, id
)))
1923 nd
= lto_splay_tree_lookup (file_ids
, id
);
1925 internal_error ("resolution sub id %wx not in object file", id
);
1928 file_data
= (struct lto_file_decl_data
*)nd
->value
;
1929 /* The indexes are very sparse. To save memory save them in a compact
1930 format that is only unpacked later when the subfile is processed. */
1933 file_data
->respairs
.safe_push (rp
);
1934 if (file_data
->max_index
< index
)
1935 file_data
->max_index
= index
;
1939 /* List of file_decl_datas */
1940 struct file_data_list
1942 struct lto_file_decl_data
*first
, *last
;
1945 /* Is the name for a id'ed LTO section? */
1948 lto_section_with_id (const char *name
, unsigned HOST_WIDE_INT
*id
)
1952 if (strncmp (name
, section_name_prefix
, strlen (section_name_prefix
)))
1954 s
= strrchr (name
, '.');
1955 return s
&& sscanf (s
, "." HOST_WIDE_INT_PRINT_HEX_PURE
, id
) == 1;
1958 /* Create file_data of each sub file id */
1961 create_subid_section_table (struct lto_section_slot
*ls
, splay_tree file_ids
,
1962 struct file_data_list
*list
)
1964 struct lto_section_slot s_slot
, *new_slot
;
1965 unsigned HOST_WIDE_INT id
;
1969 struct lto_file_decl_data
*file_data
;
1971 if (!lto_section_with_id (ls
->name
, &id
))
1974 /* Find hash table of sub module id */
1975 nd
= lto_splay_tree_lookup (file_ids
, id
);
1978 file_data
= (struct lto_file_decl_data
*)nd
->value
;
1982 file_data
= ggc_alloc
<lto_file_decl_data
> ();
1983 memset(file_data
, 0, sizeof (struct lto_file_decl_data
));
1985 file_data
->section_hash_table
= lto_obj_create_section_hash_table ();;
1986 lto_splay_tree_insert (file_ids
, id
, file_data
);
1988 /* Maintain list in linker order */
1990 list
->first
= file_data
;
1992 list
->last
->next
= file_data
;
1993 list
->last
= file_data
;
1996 /* Copy section into sub module hash table */
1997 new_name
= XDUPVEC (char, ls
->name
, strlen (ls
->name
) + 1);
1998 s_slot
.name
= new_name
;
1999 hash_slot
= htab_find_slot (file_data
->section_hash_table
, &s_slot
, INSERT
);
2000 gcc_assert (*hash_slot
== NULL
);
2002 new_slot
= XDUP (struct lto_section_slot
, ls
);
2003 new_slot
->name
= new_name
;
2004 *hash_slot
= new_slot
;
2008 /* Read declarations and other initializations for a FILE_DATA. */
2011 lto_file_finalize (struct lto_file_decl_data
*file_data
, lto_file
*file
)
2015 vec
<ld_plugin_symbol_resolution_t
>
2016 resolutions
= vNULL
;
2020 /* Create vector for fast access of resolution. We do this lazily
2022 resolutions
.safe_grow_cleared (file_data
->max_index
+ 1);
2023 for (i
= 0; file_data
->respairs
.iterate (i
, &rp
); i
++)
2024 resolutions
[rp
->index
] = rp
->res
;
2025 file_data
->respairs
.release ();
2027 file_data
->renaming_hash_table
= lto_create_renaming_table ();
2028 file_data
->file_name
= file
->filename
;
2029 #ifdef ACCEL_COMPILER
2030 lto_input_mode_table (file_data
);
2032 file_data
->mode_table
= lto_mode_identity_table
;
2034 data
= lto_get_section_data (file_data
, LTO_section_decls
, NULL
, &len
);
2037 internal_error ("cannot read LTO decls from %s", file_data
->file_name
);
2040 /* Frees resolutions */
2041 lto_read_decls (file_data
, data
, resolutions
);
2042 lto_free_section_data (file_data
, LTO_section_decls
, NULL
, data
, len
);
2045 /* Finalize FILE_DATA in FILE and increase COUNT. */
2048 lto_create_files_from_ids (lto_file
*file
, struct lto_file_decl_data
*file_data
,
2051 lto_file_finalize (file_data
, file
);
2052 if (symtab
->dump_file
)
2053 fprintf (symtab
->dump_file
,
2054 "Creating file %s with sub id " HOST_WIDE_INT_PRINT_HEX
"\n",
2055 file_data
->file_name
, file_data
->id
);
2060 /* Generate a TREE representation for all types and external decls
2063 Read all of the globals out of the file. Then read the cgraph
2064 and process the .o index into the cgraph nodes so that it can open
2065 the .o file to load the functions and ipa information. */
2067 static struct lto_file_decl_data
*
2068 lto_file_read (lto_file
*file
, FILE *resolution_file
, int *count
)
2070 struct lto_file_decl_data
*file_data
= NULL
;
2071 splay_tree file_ids
;
2072 htab_t section_hash_table
;
2073 struct lto_section_slot
*section
;
2074 struct file_data_list file_list
;
2075 struct lto_section_list section_list
;
2077 memset (§ion_list
, 0, sizeof (struct lto_section_list
));
2078 section_hash_table
= lto_obj_build_section_table (file
, §ion_list
);
2080 /* Find all sub modules in the object and put their sections into new hash
2081 tables in a splay tree. */
2082 file_ids
= lto_splay_tree_new ();
2083 memset (&file_list
, 0, sizeof (struct file_data_list
));
2084 for (section
= section_list
.first
; section
!= NULL
; section
= section
->next
)
2085 create_subid_section_table (section
, file_ids
, &file_list
);
2087 /* Add resolutions to file ids */
2088 lto_resolution_read (file_ids
, resolution_file
, file
);
2090 /* Finalize each lto file for each submodule in the merged object */
2091 for (file_data
= file_list
.first
; file_data
!= NULL
; file_data
= file_data
->next
)
2092 lto_create_files_from_ids (file
, file_data
, count
);
2094 splay_tree_delete (file_ids
);
2095 htab_delete (section_hash_table
);
2097 return file_list
.first
;
2100 #if HAVE_MMAP_FILE && HAVE_SYSCONF && defined _SC_PAGE_SIZE
2101 #define LTO_MMAP_IO 1
2105 /* Page size of machine is used for mmap and munmap calls. */
2106 static size_t page_mask
;
2109 /* Get the section data of length LEN from FILENAME starting at
2110 OFFSET. The data segment must be freed by the caller when the
2111 caller is finished. Returns NULL if all was not well. */
2114 lto_read_section_data (struct lto_file_decl_data
*file_data
,
2115 intptr_t offset
, size_t len
)
2119 static char *fd_name
;
2121 intptr_t computed_len
;
2122 intptr_t computed_offset
;
2126 /* Keep a single-entry file-descriptor cache. The last file we
2127 touched will get closed at exit.
2128 ??? Eventually we want to add a more sophisticated larger cache
2129 or rather fix function body streaming to not stream them in
2130 practically random order. */
2132 && filename_cmp (fd_name
, file_data
->file_name
) != 0)
2140 fd
= open (file_data
->file_name
, O_RDONLY
|O_BINARY
);
2143 fatal_error (input_location
, "Cannot open %s", file_data
->file_name
);
2146 fd_name
= xstrdup (file_data
->file_name
);
2152 size_t page_size
= sysconf (_SC_PAGE_SIZE
);
2153 page_mask
= ~(page_size
- 1);
2156 computed_offset
= offset
& page_mask
;
2157 diff
= offset
- computed_offset
;
2158 computed_len
= len
+ diff
;
2160 result
= (char *) mmap (NULL
, computed_len
, PROT_READ
, MAP_PRIVATE
,
2161 fd
, computed_offset
);
2162 if (result
== MAP_FAILED
)
2164 fatal_error (input_location
, "Cannot map %s", file_data
->file_name
);
2168 return result
+ diff
;
2170 result
= (char *) xmalloc (len
);
2171 if (lseek (fd
, offset
, SEEK_SET
) != offset
2172 || read (fd
, result
, len
) != (ssize_t
) len
)
2175 fatal_error (input_location
, "Cannot read %s", file_data
->file_name
);
2179 /* Native windows doesn't supports delayed unlink on opened file. So
2180 we close file here again. This produces higher I/O load, but at least
2181 it prevents to have dangling file handles preventing unlink. */
2192 /* Get the section data from FILE_DATA of SECTION_TYPE with NAME.
2193 NAME will be NULL unless the section type is for a function
2197 get_section_data (struct lto_file_decl_data
*file_data
,
2198 enum lto_section_type section_type
,
2202 htab_t section_hash_table
= file_data
->section_hash_table
;
2203 struct lto_section_slot
*f_slot
;
2204 struct lto_section_slot s_slot
;
2205 const char *section_name
= lto_get_section_name (section_type
, name
, file_data
);
2209 s_slot
.name
= section_name
;
2210 f_slot
= (struct lto_section_slot
*) htab_find (section_hash_table
, &s_slot
);
2213 data
= lto_read_section_data (file_data
, f_slot
->start
, f_slot
->len
);
2217 free (CONST_CAST (char *, section_name
));
2222 /* Free the section data from FILE_DATA of SECTION_TYPE with NAME that
2223 starts at OFFSET and has LEN bytes. */
2226 free_section_data (struct lto_file_decl_data
*file_data ATTRIBUTE_UNUSED
,
2227 enum lto_section_type section_type ATTRIBUTE_UNUSED
,
2228 const char *name ATTRIBUTE_UNUSED
,
2229 const char *offset
, size_t len ATTRIBUTE_UNUSED
)
2232 intptr_t computed_len
;
2233 intptr_t computed_offset
;
2238 computed_offset
= ((intptr_t) offset
) & page_mask
;
2239 diff
= (intptr_t) offset
- computed_offset
;
2240 computed_len
= len
+ diff
;
2242 munmap ((caddr_t
) computed_offset
, computed_len
);
2244 free (CONST_CAST(char *, offset
));
2248 static lto_file
*current_lto_file
;
2250 /* Helper for qsort; compare partitions and return one with smaller size.
2251 We sort from greatest to smallest so parallel build doesn't stale on the
2252 longest compilation being executed too late. */
2255 cmp_partitions_size (const void *a
, const void *b
)
2257 const struct ltrans_partition_def
*pa
2258 = *(struct ltrans_partition_def
*const *)a
;
2259 const struct ltrans_partition_def
*pb
2260 = *(struct ltrans_partition_def
*const *)b
;
2261 return pb
->insns
- pa
->insns
;
2264 /* Helper for qsort; compare partitions and return one with smaller order. */
2267 cmp_partitions_order (const void *a
, const void *b
)
2269 const struct ltrans_partition_def
*pa
2270 = *(struct ltrans_partition_def
*const *)a
;
2271 const struct ltrans_partition_def
*pb
2272 = *(struct ltrans_partition_def
*const *)b
;
2273 int ordera
= -1, orderb
= -1;
2275 if (lto_symtab_encoder_size (pa
->encoder
))
2276 ordera
= lto_symtab_encoder_deref (pa
->encoder
, 0)->order
;
2277 if (lto_symtab_encoder_size (pb
->encoder
))
2278 orderb
= lto_symtab_encoder_deref (pb
->encoder
, 0)->order
;
2279 return orderb
- ordera
;
2282 /* Actually stream out ENCODER into TEMP_FILENAME. */
2285 do_stream_out (char *temp_filename
, lto_symtab_encoder_t encoder
)
2287 lto_file
*file
= lto_obj_file_open (temp_filename
, true);
2289 fatal_error (input_location
, "lto_obj_file_open() failed");
2290 lto_set_current_out_file (file
);
2292 ipa_write_optimization_summaries (encoder
);
2294 lto_set_current_out_file (NULL
);
2295 lto_obj_file_close (file
);
2299 /* Wait for forked process and signal errors. */
2300 #ifdef HAVE_WORKING_FORK
2308 #define WCONTINUED 0
2310 int w
= waitpid (0, &status
, WUNTRACED
| WCONTINUED
);
2312 fatal_error (input_location
, "waitpid failed");
2314 if (WIFEXITED (status
) && WEXITSTATUS (status
))
2315 fatal_error (input_location
, "streaming subprocess failed");
2316 else if (WIFSIGNALED (status
))
2317 fatal_error (input_location
,
2318 "streaming subprocess was killed by signal");
2320 while (!WIFEXITED (status
) && !WIFSIGNALED (status
));
2324 /* Stream out ENCODER into TEMP_FILENAME
2325 Fork if that seems to help. */
2328 stream_out (char *temp_filename
, lto_symtab_encoder_t encoder
,
2329 bool ARG_UNUSED (last
))
2331 #ifdef HAVE_WORKING_FORK
2334 if (lto_parallelism
<= 1)
2336 do_stream_out (temp_filename
, encoder
);
2340 /* Do not run more than LTO_PARALLELISM streamings
2341 FIXME: we ignore limits on jobserver. */
2342 if (lto_parallelism
> 0 && nruns
>= lto_parallelism
)
2347 /* If this is not the last parallel partition, execute new
2348 streaming process. */
2351 pid_t cpid
= fork ();
2355 setproctitle ("lto1-wpa-streaming");
2356 do_stream_out (temp_filename
, encoder
);
2359 /* Fork failed; lets do the job ourseleves. */
2360 else if (cpid
== -1)
2361 do_stream_out (temp_filename
, encoder
);
2365 /* Last partition; stream it and wait for all children to die. */
2369 do_stream_out (temp_filename
, encoder
);
2370 for (i
= 0; i
< nruns
; i
++)
2373 asm_nodes_output
= true;
2375 do_stream_out (temp_filename
, encoder
);
2379 /* Write all output files in WPA mode and the file with the list of
2383 lto_wpa_write_files (void)
2386 ltrans_partition part
;
2387 FILE *ltrans_output_list_stream
;
2388 char *temp_filename
;
2389 vec
<char *>temp_filenames
= vNULL
;
2392 /* Open the LTRANS output list. */
2393 if (!ltrans_output_list
)
2394 fatal_error (input_location
, "no LTRANS output list filename provided");
2396 timevar_push (TV_WHOPR_WPA
);
2398 FOR_EACH_VEC_ELT (ltrans_partitions
, i
, part
)
2399 lto_stats
.num_output_symtab_nodes
+= lto_symtab_encoder_size (part
->encoder
);
2401 timevar_pop (TV_WHOPR_WPA
);
2403 timevar_push (TV_WHOPR_WPA_IO
);
2405 /* Generate a prefix for the LTRANS unit files. */
2406 blen
= strlen (ltrans_output_list
);
2407 temp_filename
= (char *) xmalloc (blen
+ sizeof ("2147483648.o"));
2408 strcpy (temp_filename
, ltrans_output_list
);
2409 if (blen
> sizeof (".out")
2410 && strcmp (temp_filename
+ blen
- sizeof (".out") + 1,
2412 temp_filename
[blen
- sizeof (".out") + 1] = '\0';
2413 blen
= strlen (temp_filename
);
2415 n_sets
= ltrans_partitions
.length ();
2417 /* Sort partitions by size so small ones are compiled last.
2418 FIXME: Even when not reordering we may want to output one list for parallel make
2419 and other for final link command. */
2421 if (!flag_profile_reorder_functions
|| !flag_profile_use
)
2422 ltrans_partitions
.qsort (flag_toplevel_reorder
2423 ? cmp_partitions_size
2424 : cmp_partitions_order
);
2426 for (i
= 0; i
< n_sets
; i
++)
2428 ltrans_partition part
= ltrans_partitions
[i
];
2430 /* Write all the nodes in SET. */
2431 sprintf (temp_filename
+ blen
, "%u.o", i
);
2434 fprintf (stderr
, " %s (%s %i insns)", temp_filename
, part
->name
, part
->insns
);
2435 if (symtab
->dump_file
)
2437 lto_symtab_encoder_iterator lsei
;
2439 fprintf (symtab
->dump_file
, "Writing partition %s to file %s, %i insns\n",
2440 part
->name
, temp_filename
, part
->insns
);
2441 fprintf (symtab
->dump_file
, " Symbols in partition: ");
2442 for (lsei
= lsei_start_in_partition (part
->encoder
); !lsei_end_p (lsei
);
2443 lsei_next_in_partition (&lsei
))
2445 symtab_node
*node
= lsei_node (lsei
);
2446 fprintf (symtab
->dump_file
, "%s ", node
->asm_name ());
2448 fprintf (symtab
->dump_file
, "\n Symbols in boundary: ");
2449 for (lsei
= lsei_start (part
->encoder
); !lsei_end_p (lsei
);
2452 symtab_node
*node
= lsei_node (lsei
);
2453 if (!lto_symtab_encoder_in_partition_p (part
->encoder
, node
))
2455 fprintf (symtab
->dump_file
, "%s ", node
->asm_name ());
2456 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
);
2458 && lto_symtab_encoder_encode_body_p (part
->encoder
, cnode
))
2459 fprintf (symtab
->dump_file
, "(body included)");
2462 varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
);
2464 && lto_symtab_encoder_encode_initializer_p (part
->encoder
, vnode
))
2465 fprintf (symtab
->dump_file
, "(initializer included)");
2469 fprintf (symtab
->dump_file
, "\n");
2471 gcc_checking_assert (lto_symtab_encoder_size (part
->encoder
) || !i
);
2473 stream_out (temp_filename
, part
->encoder
, i
== n_sets
- 1);
2475 part
->encoder
= NULL
;
2477 temp_filenames
.safe_push (xstrdup (temp_filename
));
2479 ltrans_output_list_stream
= fopen (ltrans_output_list
, "w");
2480 if (ltrans_output_list_stream
== NULL
)
2481 fatal_error (input_location
,
2482 "opening LTRANS output list %s: %m", ltrans_output_list
);
2483 for (i
= 0; i
< n_sets
; i
++)
2485 unsigned int len
= strlen (temp_filenames
[i
]);
2486 if (fwrite (temp_filenames
[i
], 1, len
, ltrans_output_list_stream
) < len
2487 || fwrite ("\n", 1, 1, ltrans_output_list_stream
) < 1)
2488 fatal_error (input_location
, "writing to LTRANS output list %s: %m",
2489 ltrans_output_list
);
2490 free (temp_filenames
[i
]);
2492 temp_filenames
.release();
2494 lto_stats
.num_output_files
+= n_sets
;
2496 /* Close the LTRANS output list. */
2497 if (fclose (ltrans_output_list_stream
))
2498 fatal_error (input_location
,
2499 "closing LTRANS output list %s: %m", ltrans_output_list
);
2501 free_ltrans_partitions();
2502 free (temp_filename
);
2504 timevar_pop (TV_WHOPR_WPA_IO
);
2508 /* If TT is a variable or function decl replace it with its
2509 prevailing variant. */
2510 #define LTO_SET_PREVAIL(tt) \
2512 if ((tt) && VAR_OR_FUNCTION_DECL_P (tt) \
2513 && (TREE_PUBLIC (tt) || DECL_EXTERNAL (tt))) \
2515 tt = lto_symtab_prevailing_decl (tt); \
2520 /* Ensure that TT isn't a replacable var of function decl. */
2521 #define LTO_NO_PREVAIL(tt) \
2522 gcc_checking_assert (!(tt) || !VAR_OR_FUNCTION_DECL_P (tt))
2524 /* Given a tree T replace all fields referring to variables or functions
2525 with their prevailing variant. */
2527 lto_fixup_prevailing_decls (tree t
)
2529 enum tree_code code
= TREE_CODE (t
);
2532 gcc_checking_assert (code
!= TREE_BINFO
);
2533 LTO_NO_PREVAIL (TREE_TYPE (t
));
2534 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
)
2535 /* lto_symtab_prevail_decl use TREE_CHAIN to link to the prevailing decl.
2536 in the case T is a prevailed declaration we would ICE here. */
2537 && !VAR_OR_FUNCTION_DECL_P (t
))
2538 LTO_NO_PREVAIL (TREE_CHAIN (t
));
2541 LTO_NO_PREVAIL (DECL_NAME (t
));
2542 LTO_SET_PREVAIL (DECL_CONTEXT (t
));
2543 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
2545 LTO_SET_PREVAIL (DECL_SIZE (t
));
2546 LTO_SET_PREVAIL (DECL_SIZE_UNIT (t
));
2547 LTO_SET_PREVAIL (DECL_INITIAL (t
));
2548 LTO_NO_PREVAIL (DECL_ATTRIBUTES (t
));
2549 LTO_SET_PREVAIL (DECL_ABSTRACT_ORIGIN (t
));
2551 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
2553 LTO_NO_PREVAIL (t
->decl_with_vis
.assembler_name
);
2555 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
2557 LTO_NO_PREVAIL (DECL_RESULT_FLD (t
));
2559 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
2561 LTO_NO_PREVAIL (DECL_ARGUMENTS (t
));
2562 LTO_SET_PREVAIL (DECL_FUNCTION_PERSONALITY (t
));
2563 LTO_NO_PREVAIL (DECL_VINDEX (t
));
2565 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
2567 LTO_SET_PREVAIL (DECL_FIELD_OFFSET (t
));
2568 LTO_NO_PREVAIL (DECL_BIT_FIELD_TYPE (t
));
2569 LTO_NO_PREVAIL (DECL_QUALIFIER (t
));
2570 LTO_NO_PREVAIL (DECL_FIELD_BIT_OFFSET (t
));
2571 LTO_NO_PREVAIL (DECL_FCONTEXT (t
));
2574 else if (TYPE_P (t
))
2576 LTO_NO_PREVAIL (TYPE_CACHED_VALUES (t
));
2577 LTO_SET_PREVAIL (TYPE_SIZE (t
));
2578 LTO_SET_PREVAIL (TYPE_SIZE_UNIT (t
));
2579 LTO_NO_PREVAIL (TYPE_ATTRIBUTES (t
));
2580 LTO_NO_PREVAIL (TYPE_NAME (t
));
2582 LTO_SET_PREVAIL (TYPE_MINVAL (t
));
2583 LTO_SET_PREVAIL (TYPE_MAXVAL (t
));
2584 LTO_NO_PREVAIL (t
->type_non_common
.binfo
);
2586 LTO_SET_PREVAIL (TYPE_CONTEXT (t
));
2588 LTO_NO_PREVAIL (TYPE_CANONICAL (t
));
2589 LTO_NO_PREVAIL (TYPE_MAIN_VARIANT (t
));
2590 LTO_NO_PREVAIL (TYPE_NEXT_VARIANT (t
));
2592 else if (EXPR_P (t
))
2595 for (i
= TREE_OPERAND_LENGTH (t
) - 1; i
>= 0; --i
)
2596 LTO_SET_PREVAIL (TREE_OPERAND (t
, i
));
2598 else if (TREE_CODE (t
) == CONSTRUCTOR
)
2602 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), i
, val
)
2603 LTO_SET_PREVAIL (val
);
2610 LTO_SET_PREVAIL (TREE_VALUE (t
));
2611 LTO_SET_PREVAIL (TREE_PURPOSE (t
));
2612 LTO_NO_PREVAIL (TREE_PURPOSE (t
));
2618 /* If we fixed nothing, then we missed something seen by
2620 gcc_checking_assert (fixed
);
2622 #undef LTO_SET_PREVAIL
2623 #undef LTO_NO_PREVAIL
2625 /* Helper function of lto_fixup_decls. Walks the var and fn streams in STATE,
2626 replaces var and function decls with the corresponding prevailing def. */
2629 lto_fixup_state (struct lto_in_decl_state
*state
)
2633 /* Although we only want to replace FUNCTION_DECLs and VAR_DECLs,
2634 we still need to walk from all DECLs to find the reachable
2635 FUNCTION_DECLs and VAR_DECLs. */
2636 for (si
= 0; si
< LTO_N_DECL_STREAMS
; si
++)
2638 vec
<tree
, va_gc
> *trees
= state
->streams
[si
];
2639 for (i
= 0; i
< vec_safe_length (trees
); i
++)
2641 tree t
= (*trees
)[i
];
2642 if (flag_checking
&& TYPE_P (t
))
2644 if (VAR_OR_FUNCTION_DECL_P (t
)
2645 && (TREE_PUBLIC (t
) || DECL_EXTERNAL (t
)))
2646 (*trees
)[i
] = lto_symtab_prevailing_decl (t
);
2651 /* Fix the decls from all FILES. Replaces each decl with the corresponding
2655 lto_fixup_decls (struct lto_file_decl_data
**files
)
2661 FOR_EACH_VEC_ELT ((*tree_with_vars
), i
, t
)
2662 lto_fixup_prevailing_decls (t
);
2664 for (i
= 0; files
[i
]; i
++)
2666 struct lto_file_decl_data
*file
= files
[i
];
2667 struct lto_in_decl_state
*state
= file
->global_decl_state
;
2668 lto_fixup_state (state
);
2670 hash_table
<decl_state_hasher
>::iterator iter
;
2671 lto_in_decl_state
*elt
;
2672 FOR_EACH_HASH_TABLE_ELEMENT (*file
->function_decl_states
, elt
,
2673 lto_in_decl_state
*, iter
)
2674 lto_fixup_state (elt
);
2678 static GTY((length ("lto_stats.num_input_files + 1"))) struct lto_file_decl_data
**all_file_decl_data
;
2680 /* Turn file datas for sub files into a single array, so that they look
2681 like separate files for further passes. */
2684 lto_flatten_files (struct lto_file_decl_data
**orig
, int count
, int last_file_ix
)
2686 struct lto_file_decl_data
*n
, *next
;
2689 lto_stats
.num_input_files
= count
;
2691 = ggc_cleared_vec_alloc
<lto_file_decl_data_ptr
> (count
+ 1);
2692 /* Set the hooks so that all of the ipa passes can read in their data. */
2693 lto_set_in_hooks (all_file_decl_data
, get_section_data
, free_section_data
);
2694 for (i
= 0, k
= 0; i
< last_file_ix
; i
++)
2696 for (n
= orig
[i
]; n
!= NULL
; n
= next
)
2698 all_file_decl_data
[k
++] = n
;
2703 all_file_decl_data
[k
] = NULL
;
2704 gcc_assert (k
== count
);
2707 /* Input file data before flattening (i.e. splitting them to subfiles to support
2708 incremental linking. */
2709 static int real_file_count
;
2710 static GTY((length ("real_file_count + 1"))) struct lto_file_decl_data
**real_file_decl_data
;
2712 static void print_lto_report_1 (void);
2714 /* Read all the symbols from the input files FNAMES. NFILES is the
2715 number of files requested in the command line. Instantiate a
2716 global call graph by aggregating all the sub-graphs found in each
2720 read_cgraph_and_symbols (unsigned nfiles
, const char **fnames
)
2722 unsigned int i
, last_file_ix
;
2725 struct lto_file_decl_data
**decl_data
;
2728 symtab
->initialize ();
2730 timevar_push (TV_IPA_LTO_DECL_IN
);
2732 #ifdef ACCEL_COMPILER
2733 section_name_prefix
= OFFLOAD_SECTION_NAME_PREFIX
;
2734 lto_stream_offload_p
= true;
2738 = decl_data
= ggc_cleared_vec_alloc
<lto_file_decl_data_ptr
> (nfiles
+ 1);
2739 real_file_count
= nfiles
;
2741 /* Read the resolution file. */
2743 if (resolution_file_name
)
2746 unsigned num_objects
;
2748 resolution
= fopen (resolution_file_name
, "r");
2749 if (resolution
== NULL
)
2750 fatal_error (input_location
,
2751 "could not open symbol resolution file: %m");
2753 t
= fscanf (resolution
, "%u", &num_objects
);
2754 gcc_assert (t
== 1);
2756 /* True, since the plugin splits the archives. */
2757 gcc_assert (num_objects
== nfiles
);
2759 symtab
->state
= LTO_STREAMING
;
2761 canonical_type_hash_cache
= new hash_map
<const_tree
, hashval_t
> (251);
2762 gimple_canonical_types
= htab_create (16381, gimple_canonical_type_hash
,
2763 gimple_canonical_type_eq
, NULL
);
2764 gcc_obstack_init (&tree_scc_hash_obstack
);
2765 tree_scc_hash
= new hash_table
<tree_scc_hasher
> (4096);
2767 /* Register the common node types with the canonical type machinery so
2768 we properly share alias-sets across languages and TUs. Do not
2769 expose the common nodes as type merge target - those that should be
2770 are already exposed so by pre-loading the LTO streamer caches.
2771 Do two passes - first clear TYPE_CANONICAL and then re-compute it. */
2772 for (i
= 0; i
< itk_none
; ++i
)
2773 lto_register_canonical_types (integer_types
[i
], true);
2774 for (i
= 0; i
< stk_type_kind_last
; ++i
)
2775 lto_register_canonical_types (sizetype_tab
[i
], true);
2776 for (i
= 0; i
< TI_MAX
; ++i
)
2777 lto_register_canonical_types (global_trees
[i
], true);
2778 for (i
= 0; i
< itk_none
; ++i
)
2779 lto_register_canonical_types (integer_types
[i
], false);
2780 for (i
= 0; i
< stk_type_kind_last
; ++i
)
2781 lto_register_canonical_types (sizetype_tab
[i
], false);
2782 for (i
= 0; i
< TI_MAX
; ++i
)
2783 lto_register_canonical_types (global_trees
[i
], false);
2786 fprintf (stderr
, "Reading object files:");
2788 /* Read all of the object files specified on the command line. */
2789 for (i
= 0, last_file_ix
= 0; i
< nfiles
; ++i
)
2791 struct lto_file_decl_data
*file_data
= NULL
;
2794 fprintf (stderr
, " %s", fnames
[i
]);
2798 current_lto_file
= lto_obj_file_open (fnames
[i
], false);
2799 if (!current_lto_file
)
2802 file_data
= lto_file_read (current_lto_file
, resolution
, &count
);
2805 lto_obj_file_close (current_lto_file
);
2806 free (current_lto_file
);
2807 current_lto_file
= NULL
;
2811 decl_data
[last_file_ix
++] = file_data
;
2813 lto_obj_file_close (current_lto_file
);
2814 free (current_lto_file
);
2815 current_lto_file
= NULL
;
2818 lto_flatten_files (decl_data
, count
, last_file_ix
);
2819 lto_stats
.num_input_files
= count
;
2820 ggc_free(decl_data
);
2821 real_file_decl_data
= NULL
;
2823 if (resolution_file_name
)
2824 fclose (resolution
);
2826 /* Show the LTO report before launching LTRANS. */
2827 if (flag_lto_report
|| (flag_wpa
&& flag_lto_report_wpa
))
2828 print_lto_report_1 ();
2830 /* Free gimple type merging datastructures. */
2831 delete tree_scc_hash
;
2832 tree_scc_hash
= NULL
;
2833 obstack_free (&tree_scc_hash_obstack
, NULL
);
2834 htab_delete (gimple_canonical_types
);
2835 gimple_canonical_types
= NULL
;
2836 delete canonical_type_hash_cache
;
2837 canonical_type_hash_cache
= NULL
;
2839 /* At this stage we know that majority of GGC memory is reachable.
2840 Growing the limits prevents unnecesary invocation of GGC. */
2844 /* Set the hooks so that all of the ipa passes can read in their data. */
2845 lto_set_in_hooks (all_file_decl_data
, get_section_data
, free_section_data
);
2847 timevar_pop (TV_IPA_LTO_DECL_IN
);
2850 fprintf (stderr
, "\nReading the callgraph\n");
2852 timevar_push (TV_IPA_LTO_CGRAPH_IO
);
2853 /* Read the symtab. */
2856 input_offload_tables ();
2858 /* Store resolutions into the symbol table. */
2860 ld_plugin_symbol_resolution_t
*res
;
2861 FOR_EACH_SYMBOL (snode
)
2862 if (snode
->real_symbol_p ()
2863 && snode
->lto_file_data
2864 && snode
->lto_file_data
->resolution_map
2865 && (res
= snode
->lto_file_data
->resolution_map
->get (snode
->decl
)))
2866 snode
->resolution
= *res
;
2867 for (i
= 0; all_file_decl_data
[i
]; i
++)
2868 if (all_file_decl_data
[i
]->resolution_map
)
2870 delete all_file_decl_data
[i
]->resolution_map
;
2871 all_file_decl_data
[i
]->resolution_map
= NULL
;
2874 timevar_pop (TV_IPA_LTO_CGRAPH_IO
);
2877 fprintf (stderr
, "Merging declarations\n");
2879 timevar_push (TV_IPA_LTO_DECL_MERGE
);
2880 /* Merge global decls. In ltrans mode we read merged cgraph, we do not
2881 need to care about resolving symbols again, we only need to replace
2882 duplicated declarations read from the callgraph and from function
2886 lto_symtab_merge_decls ();
2888 /* If there were errors during symbol merging bail out, we have no
2889 good way to recover here. */
2891 fatal_error (input_location
,
2892 "errors during merging of translation units");
2894 /* Fixup all decls. */
2895 lto_fixup_decls (all_file_decl_data
);
2898 ggc_free (tree_with_vars
);
2899 tree_with_vars
= NULL
;
2902 timevar_pop (TV_IPA_LTO_DECL_MERGE
);
2903 /* Each pass will set the appropriate timer. */
2906 fprintf (stderr
, "Reading summaries\n");
2908 /* Read the IPA summary data. */
2910 ipa_read_optimization_summaries ();
2912 ipa_read_summaries ();
2914 for (i
= 0; all_file_decl_data
[i
]; i
++)
2916 gcc_assert (all_file_decl_data
[i
]->symtab_node_encoder
);
2917 lto_symtab_encoder_delete (all_file_decl_data
[i
]->symtab_node_encoder
);
2918 all_file_decl_data
[i
]->symtab_node_encoder
= NULL
;
2919 lto_free_function_in_decl_state (all_file_decl_data
[i
]->global_decl_state
);
2920 all_file_decl_data
[i
]->global_decl_state
= NULL
;
2921 all_file_decl_data
[i
]->current_decl_state
= NULL
;
2924 /* Finally merge the cgraph according to the decl merging decisions. */
2925 timevar_push (TV_IPA_LTO_CGRAPH_MERGE
);
2926 if (symtab
->dump_file
)
2928 fprintf (symtab
->dump_file
, "Before merging:\n");
2929 symtab_node::dump_table (symtab
->dump_file
);
2933 lto_symtab_merge_symbols ();
2934 /* Removal of unreachable symbols is needed to make verify_symtab to pass;
2935 we are still having duplicated comdat groups containing local statics.
2936 We could also just remove them while merging. */
2937 symtab
->remove_unreachable_nodes (dump_file
);
2940 symtab
->state
= IPA_SSA
;
2941 /* FIXME: Technically all node removals happening here are useless, because
2942 WPA should not stream them. */
2944 symtab
->remove_unreachable_nodes (dump_file
);
2946 timevar_pop (TV_IPA_LTO_CGRAPH_MERGE
);
2948 /* Indicate that the cgraph is built and ready. */
2949 symtab
->function_flags_ready
= true;
2951 ggc_free (all_file_decl_data
);
2952 all_file_decl_data
= NULL
;
2956 /* Materialize all the bodies for all the nodes in the callgraph. */
2959 materialize_cgraph (void)
2961 struct cgraph_node
*node
;
2962 timevar_id_t lto_timer
;
2966 flag_wpa
? "Materializing decls:" : "Reading function bodies:");
2969 FOR_EACH_FUNCTION (node
)
2971 if (node
->lto_file_data
)
2973 lto_materialize_function (node
);
2974 lto_stats
.num_input_cgraph_nodes
++;
2979 /* Start the appropriate timer depending on the mode that we are
2981 lto_timer
= (flag_wpa
) ? TV_WHOPR_WPA
2982 : (flag_ltrans
) ? TV_WHOPR_LTRANS
2984 timevar_push (lto_timer
);
2986 current_function_decl
= NULL
;
2990 fprintf (stderr
, "\n");
2992 timevar_pop (lto_timer
);
2996 /* Show various memory usage statistics related to LTO. */
2998 print_lto_report_1 (void)
3000 const char *pfx
= (flag_lto
) ? "LTO" : (flag_wpa
) ? "WPA" : "LTRANS";
3001 fprintf (stderr
, "%s statistics\n", pfx
);
3003 fprintf (stderr
, "[%s] read %lu SCCs of average size %f\n",
3004 pfx
, num_sccs_read
, total_scc_size
/ (double)num_sccs_read
);
3005 fprintf (stderr
, "[%s] %lu tree bodies read in total\n", pfx
, total_scc_size
);
3006 if (flag_wpa
&& tree_scc_hash
)
3008 fprintf (stderr
, "[%s] tree SCC table: size %ld, %ld elements, "
3009 "collision ratio: %f\n", pfx
,
3010 (long) tree_scc_hash
->size (),
3011 (long) tree_scc_hash
->elements (),
3012 tree_scc_hash
->collisions ());
3013 hash_table
<tree_scc_hasher
>::iterator hiter
;
3014 tree_scc
*scc
, *max_scc
= NULL
;
3015 unsigned max_length
= 0;
3016 FOR_EACH_HASH_TABLE_ELEMENT (*tree_scc_hash
, scc
, x
, hiter
)
3018 unsigned length
= 0;
3020 for (; s
; s
= s
->next
)
3022 if (length
> max_length
)
3024 max_length
= length
;
3028 fprintf (stderr
, "[%s] tree SCC max chain length %u (size %u)\n",
3029 pfx
, max_length
, max_scc
->len
);
3030 fprintf (stderr
, "[%s] Compared %lu SCCs, %lu collisions (%f)\n", pfx
,
3031 num_scc_compares
, num_scc_compare_collisions
,
3032 num_scc_compare_collisions
/ (double) num_scc_compares
);
3033 fprintf (stderr
, "[%s] Merged %lu SCCs\n", pfx
, num_sccs_merged
);
3034 fprintf (stderr
, "[%s] Merged %lu tree bodies\n", pfx
,
3035 total_scc_size_merged
);
3036 fprintf (stderr
, "[%s] Merged %lu types\n", pfx
, num_merged_types
);
3037 fprintf (stderr
, "[%s] %lu types prevailed (%lu associated trees)\n",
3038 pfx
, num_prevailing_types
, num_type_scc_trees
);
3039 fprintf (stderr
, "[%s] GIMPLE canonical type table: size %ld, "
3040 "%ld elements, %ld searches, %ld collisions (ratio: %f)\n", pfx
,
3041 (long) htab_size (gimple_canonical_types
),
3042 (long) htab_elements (gimple_canonical_types
),
3043 (long) gimple_canonical_types
->searches
,
3044 (long) gimple_canonical_types
->collisions
,
3045 htab_collisions (gimple_canonical_types
));
3046 fprintf (stderr
, "[%s] GIMPLE canonical type pointer-map: "
3047 "%lu elements, %ld searches\n", pfx
,
3048 num_canonical_type_hash_entries
,
3049 num_canonical_type_hash_queries
);
3052 print_lto_report (pfx
);
3055 /* Perform whole program analysis (WPA) on the callgraph and write out the
3056 optimization plan. */
3059 do_whole_program_analysis (void)
3063 lto_parallelism
= 1;
3065 /* TODO: jobserver communicatoin is not supported, yet. */
3066 if (!strcmp (flag_wpa
, "jobserver"))
3067 lto_parallelism
= -1;
3070 lto_parallelism
= atoi (flag_wpa
);
3071 if (lto_parallelism
<= 0)
3072 lto_parallelism
= 0;
3075 timevar_start (TV_PHASE_OPT_GEN
);
3077 /* Note that since we are in WPA mode, materialize_cgraph will not
3078 actually read in all the function bodies. It only materializes
3079 the decls and cgraph nodes so that analysis can be performed. */
3080 materialize_cgraph ();
3082 /* Reading in the cgraph uses different timers, start timing WPA now. */
3083 timevar_push (TV_WHOPR_WPA
);
3085 if (pre_ipa_mem_report
)
3087 fprintf (stderr
, "Memory consumption before IPA\n");
3088 dump_memory_report (false);
3091 symtab
->function_flags_ready
= true;
3093 if (symtab
->dump_file
)
3094 symtab_node::dump_table (symtab
->dump_file
);
3095 bitmap_obstack_initialize (NULL
);
3096 symtab
->state
= IPA_SSA
;
3098 execute_ipa_pass_list (g
->get_passes ()->all_regular_ipa_passes
);
3100 if (symtab
->dump_file
)
3102 fprintf (symtab
->dump_file
, "Optimized ");
3103 symtab_node::dump_table (symtab
->dump_file
);
3106 symtab_node::checking_verify_symtab_nodes ();
3107 bitmap_obstack_release (NULL
);
3109 /* We are about to launch the final LTRANS phase, stop the WPA timer. */
3110 timevar_pop (TV_WHOPR_WPA
);
3112 timevar_push (TV_WHOPR_PARTITIONING
);
3113 if (flag_lto_partition
== LTO_PARTITION_1TO1
)
3115 else if (flag_lto_partition
== LTO_PARTITION_MAX
)
3117 else if (flag_lto_partition
== LTO_PARTITION_ONE
)
3118 lto_balanced_map (1);
3119 else if (flag_lto_partition
== LTO_PARTITION_BALANCED
)
3120 lto_balanced_map (PARAM_VALUE (PARAM_LTO_PARTITIONS
));
3124 /* Inline summaries are needed for balanced partitioning. Free them now so
3125 the memory can be used for streamer caches. */
3126 inline_free_summary ();
3128 /* AUX pointers are used by partitioning code to bookkeep number of
3129 partitions symbol is in. This is no longer needed. */
3130 FOR_EACH_SYMBOL (node
)
3133 lto_stats
.num_cgraph_partitions
+= ltrans_partitions
.length ();
3135 /* Find out statics that need to be promoted
3136 to globals with hidden visibility because they are accessed from multiple
3138 lto_promote_cross_file_statics ();
3139 timevar_pop (TV_WHOPR_PARTITIONING
);
3141 timevar_stop (TV_PHASE_OPT_GEN
);
3143 /* Collect a last time - in lto_wpa_write_files we may end up forking
3144 with the idea that this doesn't increase memory usage. So we
3145 absoultely do not want to collect after that. */
3148 timevar_start (TV_PHASE_STREAM_OUT
);
3151 fprintf (stderr
, "\nStreaming out");
3154 lto_wpa_write_files ();
3156 fprintf (stderr
, "\n");
3157 timevar_stop (TV_PHASE_STREAM_OUT
);
3159 if (post_ipa_mem_report
)
3161 fprintf (stderr
, "Memory consumption after IPA\n");
3162 dump_memory_report (false);
3165 /* Show the LTO report before launching LTRANS. */
3166 if (flag_lto_report
|| (flag_wpa
&& flag_lto_report_wpa
))
3167 print_lto_report_1 ();
3169 dump_memory_report (true);
3173 static GTY(()) tree lto_eh_personality_decl
;
3175 /* Return the LTO personality function decl. */
3178 lto_eh_personality (void)
3180 if (!lto_eh_personality_decl
)
3182 /* Use the first personality DECL for our personality if we don't
3183 support multiple ones. This ensures that we don't artificially
3184 create the need for them in a single-language program. */
3185 if (first_personality_decl
&& !dwarf2out_do_cfi_asm ())
3186 lto_eh_personality_decl
= first_personality_decl
;
3188 lto_eh_personality_decl
= lhd_gcc_personality ();
3191 return lto_eh_personality_decl
;
3194 /* Set the process name based on the LTO mode. */
3197 lto_process_name (void)
3200 setproctitle ("lto1-lto");
3202 setproctitle ("lto1-wpa");
3204 setproctitle ("lto1-ltrans");
3208 /* Initialize the LTO front end. */
3213 lto_process_name ();
3214 lto_streamer_hooks_init ();
3216 lto_set_in_hooks (NULL
, get_section_data
, free_section_data
);
3217 memset (<o_stats
, 0, sizeof (lto_stats
));
3218 bitmap_obstack_initialize (NULL
);
3219 gimple_register_cfg_hooks ();
3220 #ifndef ACCEL_COMPILER
3221 unsigned char *table
3222 = ggc_vec_alloc
<unsigned char> (MAX_MACHINE_MODE
);
3223 for (int m
= 0; m
< MAX_MACHINE_MODE
; m
++)
3225 lto_mode_identity_table
= table
;
3230 /* Main entry point for the GIMPLE front end. This front end has
3231 three main personalities:
3233 - LTO (-flto). All the object files on the command line are
3234 loaded in memory and processed as a single translation unit.
3235 This is the traditional link-time optimization behavior.
3237 - WPA (-fwpa). Only the callgraph and summary information for
3238 files in the command file are loaded. A single callgraph
3239 (without function bodies) is instantiated for the whole set of
3240 files. IPA passes are only allowed to analyze the call graph
3241 and make transformation decisions. The callgraph is
3242 partitioned, each partition is written to a new object file
3243 together with the transformation decisions.
3245 - LTRANS (-fltrans). Similar to -flto but it prevents the IPA
3246 summary files from running again. Since WPA computed summary
3247 information and decided what transformations to apply, LTRANS
3248 simply applies them. */
3253 /* LTO is called as a front end, even though it is not a front end.
3254 Because it is called as a front end, TV_PHASE_PARSING and
3255 TV_PARSE_GLOBAL are active, and we need to turn them off while
3256 doing LTO. Later we turn them back on so they are active up in
3258 timevar_pop (TV_PARSE_GLOBAL
);
3259 timevar_stop (TV_PHASE_PARSING
);
3261 timevar_start (TV_PHASE_SETUP
);
3263 /* Initialize the LTO front end. */
3266 timevar_stop (TV_PHASE_SETUP
);
3267 timevar_start (TV_PHASE_STREAM_IN
);
3269 /* Read all the symbols and call graph from all the files in the
3271 read_cgraph_and_symbols (num_in_fnames
, in_fnames
);
3273 timevar_stop (TV_PHASE_STREAM_IN
);
3277 /* If WPA is enabled analyze the whole call graph and create an
3278 optimization plan. Otherwise, read in all the function
3279 bodies and continue with optimization. */
3281 do_whole_program_analysis ();
3284 timevar_start (TV_PHASE_OPT_GEN
);
3286 materialize_cgraph ();
3288 lto_promote_statics_nonwpa ();
3290 /* Let the middle end know that we have read and merged all of
3294 timevar_stop (TV_PHASE_OPT_GEN
);
3296 /* FIXME lto, if the processes spawned by WPA fail, we miss
3297 the chance to print WPA's report, so WPA will call
3298 print_lto_report before launching LTRANS. If LTRANS was
3299 launched directly by the driver we would not need to do
3301 if (flag_lto_report
|| (flag_wpa
&& flag_lto_report_wpa
))
3302 print_lto_report_1 ();
3306 /* Here we make LTO pretend to be a parser. */
3307 timevar_start (TV_PHASE_PARSING
);
3308 timevar_push (TV_PARSE_GLOBAL
);
3311 #include "gt-lto-lto.h"