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"
31 #include "fold-const.h"
32 #include "stor-layout.h"
33 #include "diagnostic-core.h"
36 #include "basic-block.h"
38 #include "plugin-api.h"
39 #include "hard-reg-set.h"
44 #include "tree-ssa-operands.h"
45 #include "tree-pass.h"
46 #include "langhooks.h"
48 #include "alloc-pool.h"
49 #include "symbol-summary.h"
53 #include "tree-ssa-alias.h"
54 #include "internal-fn.h"
55 #include "gimple-expr.h"
59 #include "lto-streamer.h"
60 #include "lto-section-names.h"
61 #include "tree-streamer.h"
62 #include "splay-tree.h"
63 #include "lto-partition.h"
64 #include "data-streamer.h"
66 #include "pass_manager.h"
67 #include "ipa-inline.h"
69 #include "ipa-utils.h"
70 #include "gomp-constants.h"
73 /* Number of parallel tasks to run, -1 if we want to use GNU Make jobserver. */
74 static int lto_parallelism
;
76 static GTY(()) tree first_personality_decl
;
78 static GTY(()) const unsigned char *lto_mode_identity_table
;
80 /* Returns a hash code for P. */
83 hash_name (const void *p
)
85 const struct lto_section_slot
*ds
= (const struct lto_section_slot
*) p
;
86 return (hashval_t
) htab_hash_string (ds
->name
);
90 /* Returns nonzero if P1 and P2 are equal. */
93 eq_name (const void *p1
, const void *p2
)
95 const struct lto_section_slot
*s1
=
96 (const struct lto_section_slot
*) p1
;
97 const struct lto_section_slot
*s2
=
98 (const struct lto_section_slot
*) p2
;
100 return strcmp (s1
->name
, s2
->name
) == 0;
103 /* Free lto_section_slot */
106 free_with_string (void *arg
)
108 struct lto_section_slot
*s
= (struct lto_section_slot
*)arg
;
110 free (CONST_CAST (char *, s
->name
));
114 /* Create section hash table */
117 lto_obj_create_section_hash_table (void)
119 return htab_create (37, hash_name
, eq_name
, free_with_string
);
122 /* Delete an allocated integer KEY in the splay tree. */
125 lto_splay_tree_delete_id (splay_tree_key key
)
130 /* Compare splay tree node ids A and B. */
133 lto_splay_tree_compare_ids (splay_tree_key a
, splay_tree_key b
)
135 unsigned HOST_WIDE_INT ai
;
136 unsigned HOST_WIDE_INT bi
;
138 ai
= *(unsigned HOST_WIDE_INT
*) a
;
139 bi
= *(unsigned HOST_WIDE_INT
*) b
;
148 /* Look up splay tree node by ID in splay tree T. */
150 static splay_tree_node
151 lto_splay_tree_lookup (splay_tree t
, unsigned HOST_WIDE_INT id
)
153 return splay_tree_lookup (t
, (splay_tree_key
) &id
);
156 /* Check if KEY has ID. */
159 lto_splay_tree_id_equal_p (splay_tree_key key
, unsigned HOST_WIDE_INT id
)
161 return *(unsigned HOST_WIDE_INT
*) key
== id
;
164 /* Insert a splay tree node into tree T with ID as key and FILE_DATA as value.
165 The ID is allocated separately because we need HOST_WIDE_INTs which may
166 be wider than a splay_tree_key. */
169 lto_splay_tree_insert (splay_tree t
, unsigned HOST_WIDE_INT id
,
170 struct lto_file_decl_data
*file_data
)
172 unsigned HOST_WIDE_INT
*idp
= XCNEW (unsigned HOST_WIDE_INT
);
174 splay_tree_insert (t
, (splay_tree_key
) idp
, (splay_tree_value
) file_data
);
177 /* Create a splay tree. */
180 lto_splay_tree_new (void)
182 return splay_tree_new (lto_splay_tree_compare_ids
,
183 lto_splay_tree_delete_id
,
187 /* Return true when NODE has a clone that is analyzed (i.e. we need
188 to load its body even if the node itself is not needed). */
191 has_analyzed_clone_p (struct cgraph_node
*node
)
193 struct cgraph_node
*orig
= node
;
202 else if (node
->next_sibling_clone
)
203 node
= node
->next_sibling_clone
;
206 while (node
!= orig
&& !node
->next_sibling_clone
)
207 node
= node
->clone_of
;
209 node
= node
->next_sibling_clone
;
215 /* Read the function body for the function associated with NODE. */
218 lto_materialize_function (struct cgraph_node
*node
)
223 /* Read in functions with body (analyzed nodes)
224 and also functions that are needed to produce virtual clones. */
225 if ((node
->has_gimple_body_p () && node
->analyzed
)
226 || node
->used_as_abstract_origin
227 || has_analyzed_clone_p (node
))
229 /* Clones don't need to be read. */
232 if (DECL_FUNCTION_PERSONALITY (decl
) && !first_personality_decl
)
233 first_personality_decl
= DECL_FUNCTION_PERSONALITY (decl
);
236 /* Let the middle end know about the function. */
237 rest_of_decl_compilation (decl
, 1, 0);
241 /* Decode the content of memory pointed to by DATA in the in decl
242 state object STATE. DATA_IN points to a data_in structure for
243 decoding. Return the address after the decoded object in the
246 static const uint32_t *
247 lto_read_in_decl_state (struct data_in
*data_in
, const uint32_t *data
,
248 struct lto_in_decl_state
*state
)
255 decl
= streamer_tree_cache_get_tree (data_in
->reader_cache
, ix
);
256 if (!VAR_OR_FUNCTION_DECL_P (decl
))
258 gcc_assert (decl
== void_type_node
);
261 state
->fn_decl
= decl
;
263 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
265 uint32_t size
= *data
++;
266 vec
<tree
, va_gc
> *decls
= NULL
;
267 vec_alloc (decls
, size
);
269 for (j
= 0; j
< size
; j
++)
270 vec_safe_push (decls
,
271 streamer_tree_cache_get_tree (data_in
->reader_cache
,
274 state
->streams
[i
] = decls
;
282 /* Global canonical type table. */
283 static htab_t gimple_canonical_types
;
284 static hash_map
<const_tree
, hashval_t
> *canonical_type_hash_cache
;
285 static unsigned long num_canonical_type_hash_entries
;
286 static unsigned long num_canonical_type_hash_queries
;
288 static void iterative_hash_canonical_type (tree type
, inchash::hash
&hstate
);
289 static hashval_t
gimple_canonical_type_hash (const void *p
);
290 static void gimple_register_canonical_type_1 (tree t
, hashval_t hash
);
292 /* Returning a hash value for gimple type TYPE.
294 The hash value returned is equal for types considered compatible
295 by gimple_canonical_types_compatible_p. */
298 hash_canonical_type (tree type
)
300 inchash::hash hstate
;
302 /* We compute alias sets only for types that needs them.
303 Be sure we do not recurse to something else as we can not hash incomplete
304 types in a way they would have same hash value as compatible complete
306 gcc_checking_assert (type_with_alias_set_p (type
));
308 /* Combine a few common features of types so that types are grouped into
309 smaller sets; when searching for existing matching types to merge,
310 only existing types having the same features as the new type will be
312 hstate
.add_int (tree_code_for_canonical_type_merging (TREE_CODE (type
)));
313 hstate
.add_int (TYPE_MODE (type
));
315 /* Incorporate common features of numerical types. */
316 if (INTEGRAL_TYPE_P (type
)
317 || SCALAR_FLOAT_TYPE_P (type
)
318 || FIXED_POINT_TYPE_P (type
)
319 || TREE_CODE (type
) == OFFSET_TYPE
320 || POINTER_TYPE_P (type
))
322 hstate
.add_int (TYPE_UNSIGNED (type
));
323 hstate
.add_int (TYPE_PRECISION (type
));
326 if (VECTOR_TYPE_P (type
))
328 hstate
.add_int (TYPE_VECTOR_SUBPARTS (type
));
329 hstate
.add_int (TYPE_UNSIGNED (type
));
332 if (TREE_CODE (type
) == COMPLEX_TYPE
)
333 hstate
.add_int (TYPE_UNSIGNED (type
));
335 /* Fortran's C_SIGNED_CHAR is !TYPE_STRING_FLAG but needs to be
336 interoperable with "signed char". Unless all frontends are revisited to
337 agree on these types, we must ignore the flag completely. */
339 /* Fortran standard define C_PTR type that is compatible with every
340 C pointer. For this reason we need to glob all pointers into one.
341 Still pointers in different address spaces are not compatible. */
342 if (POINTER_TYPE_P (type
))
343 hstate
.add_int (TYPE_ADDR_SPACE (TREE_TYPE (type
)));
345 /* For array types hash the domain bounds and the string flag. */
346 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
348 hstate
.add_int (TYPE_STRING_FLAG (type
));
349 /* OMP lowering can introduce error_mark_node in place of
350 random local decls in types. */
351 if (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)) != error_mark_node
)
352 inchash::add_expr (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)), hstate
);
353 if (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != error_mark_node
)
354 inchash::add_expr (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)), hstate
);
357 /* Recurse for aggregates with a single element type. */
358 if (TREE_CODE (type
) == ARRAY_TYPE
359 || TREE_CODE (type
) == COMPLEX_TYPE
360 || TREE_CODE (type
) == VECTOR_TYPE
)
361 iterative_hash_canonical_type (TREE_TYPE (type
), hstate
);
363 /* Incorporate function return and argument types. */
364 if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
369 iterative_hash_canonical_type (TREE_TYPE (type
), hstate
);
371 for (p
= TYPE_ARG_TYPES (type
), na
= 0; p
; p
= TREE_CHAIN (p
))
373 iterative_hash_canonical_type (TREE_VALUE (p
), hstate
);
380 if (RECORD_OR_UNION_TYPE_P (type
))
385 for (f
= TYPE_FIELDS (type
), nf
= 0; f
; f
= TREE_CHAIN (f
))
386 if (TREE_CODE (f
) == FIELD_DECL
)
388 iterative_hash_canonical_type (TREE_TYPE (f
), hstate
);
398 /* Returning a hash value for gimple type TYPE combined with VAL. */
401 iterative_hash_canonical_type (tree type
, inchash::hash
&hstate
)
405 /* All type variants have same TYPE_CANONICAL. */
406 type
= TYPE_MAIN_VARIANT (type
);
407 /* An already processed type. */
408 if (TYPE_CANONICAL (type
))
410 type
= TYPE_CANONICAL (type
);
411 v
= gimple_canonical_type_hash (type
);
415 /* Canonical types should not be able to form SCCs by design, this
416 recursion is just because we do not register canonical types in
417 optimal order. To avoid quadratic behavior also register the
419 v
= hash_canonical_type (type
);
420 gimple_register_canonical_type_1 (type
, v
);
425 /* Returns the hash for a canonical type P. */
428 gimple_canonical_type_hash (const void *p
)
430 num_canonical_type_hash_queries
++;
431 hashval_t
*slot
= canonical_type_hash_cache
->get ((const_tree
) p
);
432 gcc_assert (slot
!= NULL
);
438 /* Returns nonzero if P1 and P2 are equal. */
441 gimple_canonical_type_eq (const void *p1
, const void *p2
)
443 const_tree t1
= (const_tree
) p1
;
444 const_tree t2
= (const_tree
) p2
;
445 return gimple_canonical_types_compatible_p (CONST_CAST_TREE (t1
),
446 CONST_CAST_TREE (t2
));
449 /* Main worker for gimple_register_canonical_type. */
452 gimple_register_canonical_type_1 (tree t
, hashval_t hash
)
456 gcc_checking_assert (TYPE_P (t
) && !TYPE_CANONICAL (t
));
458 slot
= htab_find_slot_with_hash (gimple_canonical_types
, t
, hash
, INSERT
);
461 tree new_type
= (tree
)(*slot
);
462 gcc_checking_assert (new_type
!= t
);
463 TYPE_CANONICAL (t
) = new_type
;
467 TYPE_CANONICAL (t
) = t
;
469 /* Cache the just computed hash value. */
470 num_canonical_type_hash_entries
++;
471 bool existed_p
= canonical_type_hash_cache
->put (t
, hash
);
472 gcc_assert (!existed_p
);
476 /* Register type T in the global type table gimple_types and set
477 TYPE_CANONICAL of T accordingly.
478 This is used by LTO to merge structurally equivalent types for
479 type-based aliasing purposes across different TUs and languages.
481 ??? This merging does not exactly match how the tree.c middle-end
482 functions will assign TYPE_CANONICAL when new types are created
483 during optimization (which at least happens for pointer and array
487 gimple_register_canonical_type (tree t
)
489 if (TYPE_CANONICAL (t
) || !type_with_alias_set_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 (t
->decl_with_vis
.assembler_name
);
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_MINVAL (t
));
652 CHECK_VAR (TYPE_MAXVAL (t
));
654 /* Accessor is for derived node types only. */
655 CHECK_NO_VAR (t
->type_non_common
.binfo
);
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
)
834 if (resolution
== LDPR_UNKNOWN
)
836 if (!file_data
->resolution_map
)
837 file_data
->resolution_map
838 = new hash_map
<tree
, ld_plugin_symbol_resolution
>;
839 file_data
->resolution_map
->put (decl
, resolution
);
842 /* Register DECL with the global symbol table and change its
843 name if necessary to avoid name clashes for static globals across
847 lto_register_var_decl_in_symtab (struct data_in
*data_in
, tree decl
,
852 /* Variable has file scope, not local. */
853 if (!TREE_PUBLIC (decl
)
854 && !((context
= decl_function_context (decl
))
855 && auto_var_in_fn_p (decl
, context
)))
856 rest_of_decl_compilation (decl
, 1, 0);
858 /* If this variable has already been declared, queue the
859 declaration for merging. */
860 if (TREE_PUBLIC (decl
))
861 register_resolution (data_in
->file_data
,
862 decl
, get_resolution (data_in
, ix
));
866 /* Register DECL with the global symbol table and change its
867 name if necessary to avoid name clashes for static globals across
868 different files. DATA_IN contains descriptors and tables for the
872 lto_register_function_decl_in_symtab (struct data_in
*data_in
, tree decl
,
875 /* If this variable has already been declared, queue the
876 declaration for merging. */
877 if (TREE_PUBLIC (decl
) && !DECL_ABSTRACT_P (decl
))
878 register_resolution (data_in
->file_data
,
879 decl
, get_resolution (data_in
, ix
));
883 /* For the type T re-materialize it in the type variant list and
884 the pointer/reference-to chains. */
887 lto_fixup_prevailing_type (tree t
)
889 /* The following re-creates proper variant lists while fixing up
890 the variant leaders. We do not stream TYPE_NEXT_VARIANT so the
891 variant list state before fixup is broken. */
893 /* If we are not our own variant leader link us into our new leaders
895 if (TYPE_MAIN_VARIANT (t
) != t
)
897 tree mv
= TYPE_MAIN_VARIANT (t
);
898 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (mv
);
899 TYPE_NEXT_VARIANT (mv
) = t
;
902 /* The following reconstructs the pointer chains
903 of the new pointed-to type if we are a main variant. We do
904 not stream those so they are broken before fixup. */
905 if (TREE_CODE (t
) == POINTER_TYPE
906 && TYPE_MAIN_VARIANT (t
) == t
)
908 TYPE_NEXT_PTR_TO (t
) = TYPE_POINTER_TO (TREE_TYPE (t
));
909 TYPE_POINTER_TO (TREE_TYPE (t
)) = t
;
911 else if (TREE_CODE (t
) == REFERENCE_TYPE
912 && TYPE_MAIN_VARIANT (t
) == t
)
914 TYPE_NEXT_REF_TO (t
) = TYPE_REFERENCE_TO (TREE_TYPE (t
));
915 TYPE_REFERENCE_TO (TREE_TYPE (t
)) = t
;
920 /* We keep prevailing tree SCCs in a hashtable with manual collision
921 handling (in case all hashes compare the same) and keep the colliding
922 entries in the tree_scc->next chain. */
927 /* Hash of the whole SCC. */
929 /* Number of trees in the SCC. */
931 /* Number of possible entries into the SCC (tree nodes [0..entry_len-1]
932 which share the same individual tree hash). */
934 /* The members of the SCC.
935 We only need to remember the first entry node candidate for prevailing
936 SCCs (but of course have access to all entries for SCCs we are
938 ??? For prevailing SCCs we really only need hash and the first
939 entry candidate, but that's too awkward to implement. */
943 struct tree_scc_hasher
: typed_noop_remove
<tree_scc
>
945 typedef tree_scc
*value_type
;
946 typedef tree_scc
*compare_type
;
947 static inline hashval_t
hash (const tree_scc
*);
948 static inline bool equal (const tree_scc
*, const tree_scc
*);
952 tree_scc_hasher::hash (const tree_scc
*scc
)
958 tree_scc_hasher::equal (const tree_scc
*scc1
, const tree_scc
*scc2
)
960 if (scc1
->hash
!= scc2
->hash
961 || scc1
->len
!= scc2
->len
962 || scc1
->entry_len
!= scc2
->entry_len
)
967 static hash_table
<tree_scc_hasher
> *tree_scc_hash
;
968 static struct obstack tree_scc_hash_obstack
;
970 static unsigned long num_merged_types
;
971 static unsigned long num_prevailing_types
;
972 static unsigned long num_type_scc_trees
;
973 static unsigned long total_scc_size
;
974 static unsigned long num_sccs_read
;
975 static unsigned long total_scc_size_merged
;
976 static unsigned long num_sccs_merged
;
977 static unsigned long num_scc_compares
;
978 static unsigned long num_scc_compare_collisions
;
981 /* Compare the two entries T1 and T2 of two SCCs that are possibly equal,
982 recursing through in-SCC tree edges. Returns true if the SCCs entered
983 through T1 and T2 are equal and fills in *MAP with the pairs of
984 SCC entries we visited, starting with (*MAP)[0] = T1 and (*MAP)[1] = T2. */
987 compare_tree_sccs_1 (tree t1
, tree t2
, tree
**map
)
991 /* Mark already visited nodes. */
992 TREE_ASM_WRITTEN (t2
) = 1;
994 /* Push the pair onto map. */
999 /* Compare value-fields. */
1000 #define compare_values(X) \
1002 if (X(t1) != X(t2)) \
1006 compare_values (TREE_CODE
);
1007 code
= TREE_CODE (t1
);
1011 compare_values (TREE_SIDE_EFFECTS
);
1012 compare_values (TREE_CONSTANT
);
1013 compare_values (TREE_READONLY
);
1014 compare_values (TREE_PUBLIC
);
1016 compare_values (TREE_ADDRESSABLE
);
1017 compare_values (TREE_THIS_VOLATILE
);
1019 compare_values (DECL_UNSIGNED
);
1020 else if (TYPE_P (t1
))
1021 compare_values (TYPE_UNSIGNED
);
1023 compare_values (TYPE_ARTIFICIAL
);
1025 compare_values (TREE_NO_WARNING
);
1026 compare_values (TREE_NOTHROW
);
1027 compare_values (TREE_STATIC
);
1028 if (code
!= TREE_BINFO
)
1029 compare_values (TREE_PRIVATE
);
1030 compare_values (TREE_PROTECTED
);
1031 compare_values (TREE_DEPRECATED
);
1034 compare_values (TYPE_SATURATING
);
1035 compare_values (TYPE_ADDR_SPACE
);
1037 else if (code
== SSA_NAME
)
1038 compare_values (SSA_NAME_IS_DEFAULT_DEF
);
1040 if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
1042 if (!wi::eq_p (t1
, t2
))
1046 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
1048 /* ??? No suitable compare routine available. */
1049 REAL_VALUE_TYPE r1
= TREE_REAL_CST (t1
);
1050 REAL_VALUE_TYPE r2
= TREE_REAL_CST (t2
);
1052 || r1
.decimal
!= r2
.decimal
1053 || r1
.sign
!= r2
.sign
1054 || r1
.signalling
!= r2
.signalling
1055 || r1
.canonical
!= r2
.canonical
1056 || r1
.uexp
!= r2
.uexp
)
1058 for (unsigned i
= 0; i
< SIGSZ
; ++i
)
1059 if (r1
.sig
[i
] != r2
.sig
[i
])
1063 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
1064 if (!fixed_compare (EQ_EXPR
,
1065 TREE_FIXED_CST_PTR (t1
), TREE_FIXED_CST_PTR (t2
)))
1069 /* We don't want to compare locations, so there is nothing do compare
1070 for TS_DECL_MINIMAL. */
1072 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1074 compare_values (DECL_MODE
);
1075 compare_values (DECL_NONLOCAL
);
1076 compare_values (DECL_VIRTUAL_P
);
1077 compare_values (DECL_IGNORED_P
);
1078 compare_values (DECL_ABSTRACT_P
);
1079 compare_values (DECL_ARTIFICIAL
);
1080 compare_values (DECL_USER_ALIGN
);
1081 compare_values (DECL_PRESERVE_P
);
1082 compare_values (DECL_EXTERNAL
);
1083 compare_values (DECL_GIMPLE_REG_P
);
1084 compare_values (DECL_ALIGN
);
1085 if (code
== LABEL_DECL
)
1087 compare_values (EH_LANDING_PAD_NR
);
1088 compare_values (LABEL_DECL_UID
);
1090 else if (code
== FIELD_DECL
)
1092 compare_values (DECL_PACKED
);
1093 compare_values (DECL_NONADDRESSABLE_P
);
1094 compare_values (DECL_OFFSET_ALIGN
);
1096 else if (code
== VAR_DECL
)
1098 compare_values (DECL_HAS_DEBUG_EXPR_P
);
1099 compare_values (DECL_NONLOCAL_FRAME
);
1101 if (code
== RESULT_DECL
1102 || code
== PARM_DECL
1103 || code
== VAR_DECL
)
1105 compare_values (DECL_BY_REFERENCE
);
1106 if (code
== VAR_DECL
1107 || code
== PARM_DECL
)
1108 compare_values (DECL_HAS_VALUE_EXPR_P
);
1112 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
1113 compare_values (DECL_REGISTER
);
1115 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1117 compare_values (DECL_COMMON
);
1118 compare_values (DECL_DLLIMPORT_P
);
1119 compare_values (DECL_WEAK
);
1120 compare_values (DECL_SEEN_IN_BIND_EXPR_P
);
1121 compare_values (DECL_COMDAT
);
1122 compare_values (DECL_VISIBILITY
);
1123 compare_values (DECL_VISIBILITY_SPECIFIED
);
1124 if (code
== VAR_DECL
)
1126 compare_values (DECL_HARD_REGISTER
);
1127 /* DECL_IN_TEXT_SECTION is set during final asm output only. */
1128 compare_values (DECL_IN_CONSTANT_POOL
);
1132 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1134 compare_values (DECL_BUILT_IN_CLASS
);
1135 compare_values (DECL_STATIC_CONSTRUCTOR
);
1136 compare_values (DECL_STATIC_DESTRUCTOR
);
1137 compare_values (DECL_UNINLINABLE
);
1138 compare_values (DECL_POSSIBLY_INLINED
);
1139 compare_values (DECL_IS_NOVOPS
);
1140 compare_values (DECL_IS_RETURNS_TWICE
);
1141 compare_values (DECL_IS_MALLOC
);
1142 compare_values (DECL_IS_OPERATOR_NEW
);
1143 compare_values (DECL_DECLARED_INLINE_P
);
1144 compare_values (DECL_STATIC_CHAIN
);
1145 compare_values (DECL_NO_INLINE_WARNING_P
);
1146 compare_values (DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT
);
1147 compare_values (DECL_NO_LIMIT_STACK
);
1148 compare_values (DECL_DISREGARD_INLINE_LIMITS
);
1149 compare_values (DECL_PURE_P
);
1150 compare_values (DECL_LOOPING_CONST_OR_PURE_P
);
1151 compare_values (DECL_FINAL_P
);
1152 compare_values (DECL_CXX_CONSTRUCTOR_P
);
1153 compare_values (DECL_CXX_DESTRUCTOR_P
);
1154 if (DECL_BUILT_IN_CLASS (t1
) != NOT_BUILT_IN
)
1155 compare_values (DECL_FUNCTION_CODE
);
1158 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
1160 compare_values (TYPE_MODE
);
1161 compare_values (TYPE_STRING_FLAG
);
1162 compare_values (TYPE_NEEDS_CONSTRUCTING
);
1163 if (RECORD_OR_UNION_TYPE_P (t1
))
1165 compare_values (TYPE_TRANSPARENT_AGGR
);
1166 compare_values (TYPE_FINAL_P
);
1168 else if (code
== ARRAY_TYPE
)
1169 compare_values (TYPE_NONALIASED_COMPONENT
);
1170 compare_values (TYPE_PACKED
);
1171 compare_values (TYPE_RESTRICT
);
1172 compare_values (TYPE_USER_ALIGN
);
1173 compare_values (TYPE_READONLY
);
1174 compare_values (TYPE_PRECISION
);
1175 compare_values (TYPE_ALIGN
);
1176 compare_values (TYPE_ALIAS_SET
);
1179 /* We don't want to compare locations, so there is nothing do compare
1182 /* BLOCKs are function local and we don't merge anything there, so
1183 simply refuse to merge. */
1184 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
1187 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
1188 if (strcmp (TRANSLATION_UNIT_LANGUAGE (t1
),
1189 TRANSLATION_UNIT_LANGUAGE (t2
)) != 0)
1192 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
))
1193 if (!cl_target_option_eq (TREE_TARGET_OPTION (t1
), TREE_TARGET_OPTION (t2
)))
1196 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
1197 if (memcmp (TREE_OPTIMIZATION (t1
), TREE_OPTIMIZATION (t2
),
1198 sizeof (struct cl_optimization
)) != 0)
1201 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1202 if (vec_safe_length (BINFO_BASE_ACCESSES (t1
))
1203 != vec_safe_length (BINFO_BASE_ACCESSES (t2
)))
1206 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1207 compare_values (CONSTRUCTOR_NELTS
);
1209 if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
1210 if (IDENTIFIER_LENGTH (t1
) != IDENTIFIER_LENGTH (t2
)
1211 || memcmp (IDENTIFIER_POINTER (t1
), IDENTIFIER_POINTER (t2
),
1212 IDENTIFIER_LENGTH (t1
)) != 0)
1215 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
1216 if (TREE_STRING_LENGTH (t1
) != TREE_STRING_LENGTH (t2
)
1217 || memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
1218 TREE_STRING_LENGTH (t1
)) != 0)
1221 if (code
== OMP_CLAUSE
)
1223 compare_values (OMP_CLAUSE_CODE
);
1224 switch (OMP_CLAUSE_CODE (t1
))
1226 case OMP_CLAUSE_DEFAULT
:
1227 compare_values (OMP_CLAUSE_DEFAULT_KIND
);
1229 case OMP_CLAUSE_SCHEDULE
:
1230 compare_values (OMP_CLAUSE_SCHEDULE_KIND
);
1232 case OMP_CLAUSE_DEPEND
:
1233 compare_values (OMP_CLAUSE_DEPEND_KIND
);
1235 case OMP_CLAUSE_MAP
:
1236 compare_values (OMP_CLAUSE_MAP_KIND
);
1238 case OMP_CLAUSE_PROC_BIND
:
1239 compare_values (OMP_CLAUSE_PROC_BIND_KIND
);
1241 case OMP_CLAUSE_REDUCTION
:
1242 compare_values (OMP_CLAUSE_REDUCTION_CODE
);
1243 compare_values (OMP_CLAUSE_REDUCTION_GIMPLE_INIT
);
1244 compare_values (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE
);
1251 #undef compare_values
1254 /* Compare pointer fields. */
1256 /* Recurse. Search & Replaced from DFS_write_tree_body.
1257 Folding the early checks into the compare_tree_edges recursion
1258 macro makes debugging way quicker as you are able to break on
1259 compare_tree_sccs_1 and simply finish until a call returns false
1260 to spot the SCC members with the difference. */
1261 #define compare_tree_edges(E1, E2) \
1263 tree t1_ = (E1), t2_ = (E2); \
1266 || !TREE_VISITED (t2_) \
1267 || (!TREE_ASM_WRITTEN (t2_) \
1268 && !compare_tree_sccs_1 (t1_, t2_, map)))) \
1270 /* Only non-NULL trees outside of the SCC may compare equal. */ \
1271 gcc_checking_assert (t1_ != t2_ || (!t2_ || !TREE_VISITED (t2_))); \
1274 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
1276 if (code
!= IDENTIFIER_NODE
)
1277 compare_tree_edges (TREE_TYPE (t1
), TREE_TYPE (t2
));
1280 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
1283 /* Note that the number of elements for EXPR has already been emitted
1284 in EXPR's header (see streamer_write_tree_header). */
1285 for (i
= 0; i
< VECTOR_CST_NELTS (t1
); ++i
)
1286 compare_tree_edges (VECTOR_CST_ELT (t1
, i
), VECTOR_CST_ELT (t2
, i
));
1289 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
1291 compare_tree_edges (TREE_REALPART (t1
), TREE_REALPART (t2
));
1292 compare_tree_edges (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
1295 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
1297 compare_tree_edges (DECL_NAME (t1
), DECL_NAME (t2
));
1298 /* ??? Global decls from different TUs have non-matching
1299 TRANSLATION_UNIT_DECLs. Only consider a small set of
1300 decls equivalent, we should not end up merging others. */
1301 if ((code
== TYPE_DECL
1302 || code
== NAMESPACE_DECL
1303 || code
== IMPORTED_DECL
1304 || code
== CONST_DECL
1305 || (VAR_OR_FUNCTION_DECL_P (t1
)
1306 && (TREE_PUBLIC (t1
) || DECL_EXTERNAL (t1
))))
1307 && DECL_FILE_SCOPE_P (t1
) && DECL_FILE_SCOPE_P (t2
))
1310 compare_tree_edges (DECL_CONTEXT (t1
), DECL_CONTEXT (t2
));
1313 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1315 compare_tree_edges (DECL_SIZE (t1
), DECL_SIZE (t2
));
1316 compare_tree_edges (DECL_SIZE_UNIT (t1
), DECL_SIZE_UNIT (t2
));
1317 compare_tree_edges (DECL_ATTRIBUTES (t1
), DECL_ATTRIBUTES (t2
));
1318 if ((code
== VAR_DECL
1319 || code
== PARM_DECL
)
1320 && DECL_HAS_VALUE_EXPR_P (t1
))
1321 compare_tree_edges (DECL_VALUE_EXPR (t1
), DECL_VALUE_EXPR (t2
));
1322 if (code
== VAR_DECL
1323 && DECL_HAS_DEBUG_EXPR_P (t1
))
1324 compare_tree_edges (DECL_DEBUG_EXPR (t1
), DECL_DEBUG_EXPR (t2
));
1325 /* LTO specific edges. */
1326 if (code
!= FUNCTION_DECL
1327 && code
!= TRANSLATION_UNIT_DECL
)
1328 compare_tree_edges (DECL_INITIAL (t1
), DECL_INITIAL (t2
));
1331 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
1333 if (code
== FUNCTION_DECL
)
1336 for (a1
= DECL_ARGUMENTS (t1
), a2
= DECL_ARGUMENTS (t2
);
1338 a1
= TREE_CHAIN (a1
), a2
= TREE_CHAIN (a2
))
1339 compare_tree_edges (a1
, a2
);
1340 compare_tree_edges (DECL_RESULT (t1
), DECL_RESULT (t2
));
1342 else if (code
== TYPE_DECL
)
1343 compare_tree_edges (DECL_ORIGINAL_TYPE (t1
), DECL_ORIGINAL_TYPE (t2
));
1346 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1348 /* Make sure we don't inadvertently set the assembler name. */
1349 if (DECL_ASSEMBLER_NAME_SET_P (t1
))
1350 compare_tree_edges (DECL_ASSEMBLER_NAME (t1
),
1351 DECL_ASSEMBLER_NAME (t2
));
1354 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
1356 compare_tree_edges (DECL_FIELD_OFFSET (t1
), DECL_FIELD_OFFSET (t2
));
1357 compare_tree_edges (DECL_BIT_FIELD_TYPE (t1
), DECL_BIT_FIELD_TYPE (t2
));
1358 compare_tree_edges (DECL_BIT_FIELD_REPRESENTATIVE (t1
),
1359 DECL_BIT_FIELD_REPRESENTATIVE (t2
));
1360 compare_tree_edges (DECL_FIELD_BIT_OFFSET (t1
),
1361 DECL_FIELD_BIT_OFFSET (t2
));
1362 compare_tree_edges (DECL_FCONTEXT (t1
), DECL_FCONTEXT (t2
));
1365 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1367 compare_tree_edges (DECL_FUNCTION_PERSONALITY (t1
),
1368 DECL_FUNCTION_PERSONALITY (t2
));
1369 compare_tree_edges (DECL_VINDEX (t1
), DECL_VINDEX (t2
));
1370 compare_tree_edges (DECL_FUNCTION_SPECIFIC_TARGET (t1
),
1371 DECL_FUNCTION_SPECIFIC_TARGET (t2
));
1372 compare_tree_edges (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t1
),
1373 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t2
));
1376 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
1378 compare_tree_edges (TYPE_SIZE (t1
), TYPE_SIZE (t2
));
1379 compare_tree_edges (TYPE_SIZE_UNIT (t1
), TYPE_SIZE_UNIT (t2
));
1380 compare_tree_edges (TYPE_ATTRIBUTES (t1
), TYPE_ATTRIBUTES (t2
));
1381 compare_tree_edges (TYPE_NAME (t1
), TYPE_NAME (t2
));
1382 /* Do not compare TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
1383 reconstructed during fixup. */
1384 /* Do not compare TYPE_NEXT_VARIANT, we reconstruct the variant lists
1386 compare_tree_edges (TYPE_MAIN_VARIANT (t1
), TYPE_MAIN_VARIANT (t2
));
1387 /* ??? Global types from different TUs have non-matching
1388 TRANSLATION_UNIT_DECLs. Still merge them if they are otherwise
1390 if (TYPE_FILE_SCOPE_P (t1
) && TYPE_FILE_SCOPE_P (t2
))
1393 compare_tree_edges (TYPE_CONTEXT (t1
), TYPE_CONTEXT (t2
));
1394 /* TYPE_CANONICAL is re-computed during type merging, so do not
1396 compare_tree_edges (TYPE_STUB_DECL (t1
), TYPE_STUB_DECL (t2
));
1399 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
1401 if (code
== ENUMERAL_TYPE
)
1402 compare_tree_edges (TYPE_VALUES (t1
), TYPE_VALUES (t2
));
1403 else if (code
== ARRAY_TYPE
)
1404 compare_tree_edges (TYPE_DOMAIN (t1
), TYPE_DOMAIN (t2
));
1405 else if (RECORD_OR_UNION_TYPE_P (t1
))
1408 for (f1
= TYPE_FIELDS (t1
), f2
= TYPE_FIELDS (t2
);
1410 f1
= TREE_CHAIN (f1
), f2
= TREE_CHAIN (f2
))
1411 compare_tree_edges (f1
, f2
);
1412 compare_tree_edges (TYPE_BINFO (t1
), TYPE_BINFO (t2
));
1414 else if (code
== FUNCTION_TYPE
1415 || code
== METHOD_TYPE
)
1416 compare_tree_edges (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
));
1417 if (!POINTER_TYPE_P (t1
))
1418 compare_tree_edges (TYPE_MINVAL (t1
), TYPE_MINVAL (t2
));
1419 compare_tree_edges (TYPE_MAXVAL (t1
), TYPE_MAXVAL (t2
));
1422 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
1424 compare_tree_edges (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
));
1425 compare_tree_edges (TREE_VALUE (t1
), TREE_VALUE (t2
));
1426 compare_tree_edges (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
1429 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1430 for (int i
= 0; i
< TREE_VEC_LENGTH (t1
); i
++)
1431 compare_tree_edges (TREE_VEC_ELT (t1
, i
), TREE_VEC_ELT (t2
, i
));
1433 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
1435 for (int i
= 0; i
< TREE_OPERAND_LENGTH (t1
); i
++)
1436 compare_tree_edges (TREE_OPERAND (t1
, i
),
1437 TREE_OPERAND (t2
, i
));
1439 /* BLOCKs are function local and we don't merge anything there. */
1440 if (TREE_BLOCK (t1
) || TREE_BLOCK (t2
))
1444 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1448 /* Lengths have already been compared above. */
1449 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (t1
), i
, t
)
1450 compare_tree_edges (t
, BINFO_BASE_BINFO (t2
, i
));
1451 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (t1
), i
, t
)
1452 compare_tree_edges (t
, BINFO_BASE_ACCESS (t2
, i
));
1453 compare_tree_edges (BINFO_OFFSET (t1
), BINFO_OFFSET (t2
));
1454 compare_tree_edges (BINFO_VTABLE (t1
), BINFO_VTABLE (t2
));
1455 compare_tree_edges (BINFO_VPTR_FIELD (t1
), BINFO_VPTR_FIELD (t2
));
1456 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
1457 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
1460 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1464 /* Lengths have already been compared above. */
1465 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, index
, value
)
1467 compare_tree_edges (index
, CONSTRUCTOR_ELT (t2
, i
)->index
);
1468 compare_tree_edges (value
, CONSTRUCTOR_ELT (t2
, i
)->value
);
1472 if (code
== OMP_CLAUSE
)
1476 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (t1
)]; i
++)
1477 compare_tree_edges (OMP_CLAUSE_OPERAND (t1
, i
),
1478 OMP_CLAUSE_OPERAND (t2
, i
));
1479 compare_tree_edges (OMP_CLAUSE_CHAIN (t1
), OMP_CLAUSE_CHAIN (t2
));
1482 #undef compare_tree_edges
1487 /* Compare the tree scc SCC to the prevailing candidate PSCC, filling
1488 out MAP if they are equal. */
1491 compare_tree_sccs (tree_scc
*pscc
, tree_scc
*scc
,
1494 /* Assume SCC entry hashes are sorted after their cardinality. Which
1495 means we can simply take the first n-tuple of equal hashes
1496 (which is recorded as entry_len) and do n SCC entry candidate
1498 for (unsigned i
= 0; i
< pscc
->entry_len
; ++i
)
1501 num_scc_compare_collisions
++;
1502 if (compare_tree_sccs_1 (pscc
->entries
[0], scc
->entries
[i
], &mapp
))
1504 /* Equal - no need to reset TREE_VISITED or TREE_ASM_WRITTEN
1505 on the scc as all trees will be freed. */
1508 /* Reset TREE_ASM_WRITTEN on scc for the next compare or in case
1509 the SCC prevails. */
1510 for (unsigned j
= 0; j
< scc
->len
; ++j
)
1511 TREE_ASM_WRITTEN (scc
->entries
[j
]) = 0;
1517 /* QSort sort function to sort a map of two pointers after the 2nd
1521 cmp_tree (const void *p1_
, const void *p2_
)
1523 tree
*p1
= (tree
*)(const_cast<void *>(p1_
));
1524 tree
*p2
= (tree
*)(const_cast<void *>(p2_
));
1527 return ((uintptr_t)p1
[1] < (uintptr_t)p2
[1]) ? -1 : 1;
1530 /* Try to unify the SCC with nodes FROM to FROM + LEN in CACHE and
1531 hash value SCC_HASH with an already recorded SCC. Return true if
1532 that was successful, otherwise return false. */
1535 unify_scc (struct data_in
*data_in
, unsigned from
,
1536 unsigned len
, unsigned scc_entry_len
, hashval_t scc_hash
)
1538 bool unified_p
= false;
1539 struct streamer_tree_cache_d
*cache
= data_in
->reader_cache
;
1541 = (tree_scc
*) alloca (sizeof (tree_scc
) + (len
- 1) * sizeof (tree
));
1543 scc
->hash
= scc_hash
;
1545 scc
->entry_len
= scc_entry_len
;
1546 for (unsigned i
= 0; i
< len
; ++i
)
1548 tree t
= streamer_tree_cache_get_tree (cache
, from
+ i
);
1549 scc
->entries
[i
] = t
;
1550 /* Do not merge SCCs with local entities inside them. Also do
1551 not merge TRANSLATION_UNIT_DECLs. */
1552 if (TREE_CODE (t
) == TRANSLATION_UNIT_DECL
1553 || (VAR_OR_FUNCTION_DECL_P (t
)
1554 && !(TREE_PUBLIC (t
) || DECL_EXTERNAL (t
)))
1555 || TREE_CODE (t
) == LABEL_DECL
)
1557 /* Avoid doing any work for these cases and do not worry to
1558 record the SCCs for further merging. */
1563 /* Look for the list of candidate SCCs to compare against. */
1565 slot
= tree_scc_hash
->find_slot_with_hash (scc
, scc_hash
, INSERT
);
1568 /* Try unifying against each candidate. */
1571 /* Set TREE_VISITED on the scc so we can easily identify tree nodes
1572 outside of the scc when following tree edges. Make sure
1573 that TREE_ASM_WRITTEN is unset so we can use it as 2nd bit
1574 to track whether we visited the SCC member during the compare.
1575 We cannot use TREE_VISITED on the pscc members as the extended
1576 scc and pscc can overlap. */
1577 for (unsigned i
= 0; i
< scc
->len
; ++i
)
1579 TREE_VISITED (scc
->entries
[i
]) = 1;
1580 gcc_checking_assert (!TREE_ASM_WRITTEN (scc
->entries
[i
]));
1583 tree
*map
= XALLOCAVEC (tree
, 2 * len
);
1584 for (tree_scc
*pscc
= *slot
; pscc
; pscc
= pscc
->next
)
1586 if (!compare_tree_sccs (pscc
, scc
, map
))
1589 /* Found an equal SCC. */
1591 num_scc_compare_collisions
--;
1593 total_scc_size_merged
+= len
;
1595 #ifdef ENABLE_CHECKING
1596 for (unsigned i
= 0; i
< len
; ++i
)
1598 tree t
= map
[2*i
+1];
1599 enum tree_code code
= TREE_CODE (t
);
1600 /* IDENTIFIER_NODEs should be singletons and are merged by the
1601 streamer. The others should be singletons, too, and we
1602 should not merge them in any way. */
1603 gcc_assert (code
!= TRANSLATION_UNIT_DECL
1604 && code
!= IDENTIFIER_NODE
1605 && !streamer_handle_as_builtin_p (t
));
1609 /* Fixup the streamer cache with the prevailing nodes according
1610 to the tree node mapping computed by compare_tree_sccs. */
1612 streamer_tree_cache_replace_tree (cache
, pscc
->entries
[0], from
);
1615 tree
*map2
= XALLOCAVEC (tree
, 2 * len
);
1616 for (unsigned i
= 0; i
< len
; ++i
)
1618 map2
[i
*2] = (tree
)(uintptr_t)(from
+ i
);
1619 map2
[i
*2+1] = scc
->entries
[i
];
1621 qsort (map2
, len
, 2 * sizeof (tree
), cmp_tree
);
1622 qsort (map
, len
, 2 * sizeof (tree
), cmp_tree
);
1623 for (unsigned i
= 0; i
< len
; ++i
)
1624 streamer_tree_cache_replace_tree (cache
, map
[2*i
],
1625 (uintptr_t)map2
[2*i
]);
1628 /* Free the tree nodes from the read SCC. */
1629 data_in
->location_cache
.revert_location_cache ();
1630 for (unsigned i
= 0; i
< len
; ++i
)
1632 enum tree_code code
;
1633 if (TYPE_P (scc
->entries
[i
]))
1635 code
= TREE_CODE (scc
->entries
[i
]);
1636 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1637 vec_free (CONSTRUCTOR_ELTS (scc
->entries
[i
]));
1638 ggc_free (scc
->entries
[i
]);
1644 /* Reset TREE_VISITED if we didn't unify the SCC with another. */
1646 for (unsigned i
= 0; i
< scc
->len
; ++i
)
1647 TREE_VISITED (scc
->entries
[i
]) = 0;
1650 /* If we didn't unify it to any candidate duplicate the relevant
1651 pieces to permanent storage and link it into the chain. */
1655 = XOBNEWVAR (&tree_scc_hash_obstack
, tree_scc
, sizeof (tree_scc
));
1656 memcpy (pscc
, scc
, sizeof (tree_scc
));
1657 pscc
->next
= (*slot
);
1664 /* Read all the symbols from buffer DATA, using descriptors in DECL_DATA.
1665 RESOLUTIONS is the set of symbols picked by the linker (read from the
1666 resolution file when the linker plugin is being used). */
1669 lto_read_decls (struct lto_file_decl_data
*decl_data
, const void *data
,
1670 vec
<ld_plugin_symbol_resolution_t
> resolutions
)
1672 const struct lto_decl_header
*header
= (const struct lto_decl_header
*) data
;
1673 const int decl_offset
= sizeof (struct lto_decl_header
);
1674 const int main_offset
= decl_offset
+ header
->decl_state_size
;
1675 const int string_offset
= main_offset
+ header
->main_size
;
1676 struct data_in
*data_in
;
1678 const uint32_t *data_ptr
, *data_end
;
1679 uint32_t num_decl_states
;
1681 lto_input_block
ib_main ((const char *) data
+ main_offset
,
1682 header
->main_size
, decl_data
->mode_table
);
1684 data_in
= lto_data_in_create (decl_data
, (const char *) data
+ string_offset
,
1685 header
->string_size
, resolutions
);
1687 /* We do not uniquify the pre-loaded cache entries, those are middle-end
1688 internal types that should not be merged. */
1690 /* Read the global declarations and types. */
1691 while (ib_main
.p
< ib_main
.len
)
1694 unsigned from
= data_in
->reader_cache
->nodes
.length ();
1695 /* Read and uniquify SCCs as in the input stream. */
1696 enum LTO_tags tag
= streamer_read_record_start (&ib_main
);
1697 if (tag
== LTO_tree_scc
)
1700 unsigned scc_entry_len
;
1701 hashval_t scc_hash
= lto_input_scc (&ib_main
, data_in
, &len_
,
1703 unsigned len
= data_in
->reader_cache
->nodes
.length () - from
;
1704 gcc_assert (len
== len_
);
1706 total_scc_size
+= len
;
1709 /* We have the special case of size-1 SCCs that are pre-merged
1710 by means of identifier and string sharing for example.
1711 ??? Maybe we should avoid streaming those as SCCs. */
1712 tree first
= streamer_tree_cache_get_tree (data_in
->reader_cache
,
1715 && (TREE_CODE (first
) == IDENTIFIER_NODE
1716 || TREE_CODE (first
) == INTEGER_CST
1717 || TREE_CODE (first
) == TRANSLATION_UNIT_DECL
1718 || streamer_handle_as_builtin_p (first
)))
1721 /* Try to unify the SCC with already existing ones. */
1723 && unify_scc (data_in
, from
,
1724 len
, scc_entry_len
, scc_hash
))
1727 /* Tree merging failed, mark entries in location cache as
1729 data_in
->location_cache
.accept_location_cache ();
1731 bool seen_type
= false;
1732 for (unsigned i
= 0; i
< len
; ++i
)
1734 tree t
= streamer_tree_cache_get_tree (data_in
->reader_cache
,
1736 /* Reconstruct the type variant and pointer-to/reference-to
1741 num_prevailing_types
++;
1742 lto_fixup_prevailing_type (t
);
1744 /* Compute the canonical type of all types.
1745 ??? Should be able to assert that !TYPE_CANONICAL. */
1746 if (TYPE_P (t
) && !TYPE_CANONICAL (t
))
1748 gimple_register_canonical_type (t
);
1750 register_odr_type (t
);
1752 /* Link shared INTEGER_CSTs into TYPE_CACHED_VALUEs of its
1753 type which is also member of this SCC. */
1754 if (TREE_CODE (t
) == INTEGER_CST
1755 && !TREE_OVERFLOW (t
))
1756 cache_integer_cst (t
);
1757 /* Register TYPE_DECLs with the debuginfo machinery. */
1759 && TREE_CODE (t
) == TYPE_DECL
)
1761 /* Dwarf2out needs location information.
1762 TODO: Moving this out of the streamer loop may noticealy
1763 improve ltrans linemap memory use. */
1764 data_in
->location_cache
.apply_location_cache ();
1765 debug_hooks
->type_decl (t
, !DECL_FILE_SCOPE_P (t
));
1769 /* Register variables and functions with the
1771 if (TREE_CODE (t
) == VAR_DECL
)
1772 lto_register_var_decl_in_symtab (data_in
, t
, from
+ i
);
1773 else if (TREE_CODE (t
) == FUNCTION_DECL
1774 && !DECL_BUILT_IN (t
))
1775 lto_register_function_decl_in_symtab (data_in
, t
, from
+ i
);
1776 /* Scan the tree for references to global functions or
1777 variables and record those for later fixup. */
1778 if (mentions_vars_p (t
))
1779 vec_safe_push (tree_with_vars
, t
);
1783 num_type_scc_trees
+= len
;
1787 /* Pickle stray references. */
1788 t
= lto_input_tree_1 (&ib_main
, data_in
, tag
, 0);
1789 gcc_assert (t
&& data_in
->reader_cache
->nodes
.length () == from
);
1792 data_in
->location_cache
.apply_location_cache ();
1794 /* Read in lto_in_decl_state objects. */
1795 data_ptr
= (const uint32_t *) ((const char*) data
+ decl_offset
);
1797 (const uint32_t *) ((const char*) data_ptr
+ header
->decl_state_size
);
1798 num_decl_states
= *data_ptr
++;
1800 gcc_assert (num_decl_states
> 0);
1801 decl_data
->global_decl_state
= lto_new_in_decl_state ();
1802 data_ptr
= lto_read_in_decl_state (data_in
, data_ptr
,
1803 decl_data
->global_decl_state
);
1805 /* Read in per-function decl states and enter them in hash table. */
1806 decl_data
->function_decl_states
=
1807 hash_table
<decl_state_hasher
>::create_ggc (37);
1809 for (i
= 1; i
< num_decl_states
; i
++)
1811 struct lto_in_decl_state
*state
= lto_new_in_decl_state ();
1813 data_ptr
= lto_read_in_decl_state (data_in
, data_ptr
, state
);
1814 lto_in_decl_state
**slot
1815 = decl_data
->function_decl_states
->find_slot (state
, INSERT
);
1816 gcc_assert (*slot
== NULL
);
1820 if (data_ptr
!= data_end
)
1821 internal_error ("bytecode stream: garbage at the end of symbols section");
1823 /* Set the current decl state to be the global state. */
1824 decl_data
->current_decl_state
= decl_data
->global_decl_state
;
1826 lto_data_in_delete (data_in
);
1829 /* Custom version of strtoll, which is not portable. */
1832 lto_parse_hex (const char *p
)
1836 for (; *p
!= '\0'; ++p
)
1841 if (c
>= '0' && c
<= '9')
1843 else if (c
>= 'a' && c
<= 'f')
1844 part
= c
- 'a' + 10;
1845 else if (c
>= 'A' && c
<= 'F')
1846 part
= c
- 'A' + 10;
1848 internal_error ("could not parse hex number");
1855 /* Read resolution for file named FILE_NAME. The resolution is read from
1859 lto_resolution_read (splay_tree file_ids
, FILE *resolution
, lto_file
*file
)
1861 /* We require that objects in the resolution file are in the same
1862 order as the lto1 command line. */
1863 unsigned int name_len
;
1865 unsigned int num_symbols
;
1867 struct lto_file_decl_data
*file_data
;
1868 splay_tree_node nd
= NULL
;
1873 name_len
= strlen (file
->filename
);
1874 obj_name
= XNEWVEC (char, name_len
+ 1);
1875 fscanf (resolution
, " "); /* Read white space. */
1877 fread (obj_name
, sizeof (char), name_len
, resolution
);
1878 obj_name
[name_len
] = '\0';
1879 if (filename_cmp (obj_name
, file
->filename
) != 0)
1880 internal_error ("unexpected file name %s in linker resolution file. "
1881 "Expected %s", obj_name
, file
->filename
);
1882 if (file
->offset
!= 0)
1887 t
= fscanf (resolution
, "@0x%16s", offset_p
);
1889 internal_error ("could not parse file offset");
1890 offset
= lto_parse_hex (offset_p
);
1891 if (offset
!= file
->offset
)
1892 internal_error ("unexpected offset");
1897 fscanf (resolution
, "%u", &num_symbols
);
1899 for (i
= 0; i
< num_symbols
; i
++)
1903 unsigned HOST_WIDE_INT id
;
1905 enum ld_plugin_symbol_resolution r
= (enum ld_plugin_symbol_resolution
) 0;
1907 unsigned int lto_resolution_str_len
=
1908 sizeof (lto_resolution_str
) / sizeof (char *);
1911 t
= fscanf (resolution
, "%u " HOST_WIDE_INT_PRINT_HEX_PURE
" %26s %*[^\n]\n",
1912 &index
, &id
, r_str
);
1914 internal_error ("invalid line in the resolution file");
1916 for (j
= 0; j
< lto_resolution_str_len
; j
++)
1918 if (strcmp (lto_resolution_str
[j
], r_str
) == 0)
1920 r
= (enum ld_plugin_symbol_resolution
) j
;
1924 if (j
== lto_resolution_str_len
)
1925 internal_error ("invalid resolution in the resolution file");
1927 if (!(nd
&& lto_splay_tree_id_equal_p (nd
->key
, id
)))
1929 nd
= lto_splay_tree_lookup (file_ids
, id
);
1931 internal_error ("resolution sub id %wx not in object file", id
);
1934 file_data
= (struct lto_file_decl_data
*)nd
->value
;
1935 /* The indexes are very sparse. To save memory save them in a compact
1936 format that is only unpacked later when the subfile is processed. */
1939 file_data
->respairs
.safe_push (rp
);
1940 if (file_data
->max_index
< index
)
1941 file_data
->max_index
= index
;
1945 /* List of file_decl_datas */
1946 struct file_data_list
1948 struct lto_file_decl_data
*first
, *last
;
1951 /* Is the name for a id'ed LTO section? */
1954 lto_section_with_id (const char *name
, unsigned HOST_WIDE_INT
*id
)
1958 if (strncmp (name
, section_name_prefix
, strlen (section_name_prefix
)))
1960 s
= strrchr (name
, '.');
1961 return s
&& sscanf (s
, "." HOST_WIDE_INT_PRINT_HEX_PURE
, id
) == 1;
1964 /* Create file_data of each sub file id */
1967 create_subid_section_table (struct lto_section_slot
*ls
, splay_tree file_ids
,
1968 struct file_data_list
*list
)
1970 struct lto_section_slot s_slot
, *new_slot
;
1971 unsigned HOST_WIDE_INT id
;
1975 struct lto_file_decl_data
*file_data
;
1977 if (!lto_section_with_id (ls
->name
, &id
))
1980 /* Find hash table of sub module id */
1981 nd
= lto_splay_tree_lookup (file_ids
, id
);
1984 file_data
= (struct lto_file_decl_data
*)nd
->value
;
1988 file_data
= ggc_alloc
<lto_file_decl_data
> ();
1989 memset(file_data
, 0, sizeof (struct lto_file_decl_data
));
1991 file_data
->section_hash_table
= lto_obj_create_section_hash_table ();;
1992 lto_splay_tree_insert (file_ids
, id
, file_data
);
1994 /* Maintain list in linker order */
1996 list
->first
= file_data
;
1998 list
->last
->next
= file_data
;
1999 list
->last
= file_data
;
2002 /* Copy section into sub module hash table */
2003 new_name
= XDUPVEC (char, ls
->name
, strlen (ls
->name
) + 1);
2004 s_slot
.name
= new_name
;
2005 hash_slot
= htab_find_slot (file_data
->section_hash_table
, &s_slot
, INSERT
);
2006 gcc_assert (*hash_slot
== NULL
);
2008 new_slot
= XDUP (struct lto_section_slot
, ls
);
2009 new_slot
->name
= new_name
;
2010 *hash_slot
= new_slot
;
2014 /* Read declarations and other initializations for a FILE_DATA. */
2017 lto_file_finalize (struct lto_file_decl_data
*file_data
, lto_file
*file
)
2021 vec
<ld_plugin_symbol_resolution_t
>
2022 resolutions
= vNULL
;
2026 /* Create vector for fast access of resolution. We do this lazily
2028 resolutions
.safe_grow_cleared (file_data
->max_index
+ 1);
2029 for (i
= 0; file_data
->respairs
.iterate (i
, &rp
); i
++)
2030 resolutions
[rp
->index
] = rp
->res
;
2031 file_data
->respairs
.release ();
2033 file_data
->renaming_hash_table
= lto_create_renaming_table ();
2034 file_data
->file_name
= file
->filename
;
2035 #ifdef ACCEL_COMPILER
2036 lto_input_mode_table (file_data
);
2038 file_data
->mode_table
= lto_mode_identity_table
;
2040 data
= lto_get_section_data (file_data
, LTO_section_decls
, NULL
, &len
);
2043 internal_error ("cannot read LTO decls from %s", file_data
->file_name
);
2046 /* Frees resolutions */
2047 lto_read_decls (file_data
, data
, resolutions
);
2048 lto_free_section_data (file_data
, LTO_section_decls
, NULL
, data
, len
);
2051 /* Finalize FILE_DATA in FILE and increase COUNT. */
2054 lto_create_files_from_ids (lto_file
*file
, struct lto_file_decl_data
*file_data
,
2057 lto_file_finalize (file_data
, file
);
2058 if (symtab
->dump_file
)
2059 fprintf (symtab
->dump_file
,
2060 "Creating file %s with sub id " HOST_WIDE_INT_PRINT_HEX
"\n",
2061 file_data
->file_name
, file_data
->id
);
2066 /* Generate a TREE representation for all types and external decls
2069 Read all of the globals out of the file. Then read the cgraph
2070 and process the .o index into the cgraph nodes so that it can open
2071 the .o file to load the functions and ipa information. */
2073 static struct lto_file_decl_data
*
2074 lto_file_read (lto_file
*file
, FILE *resolution_file
, int *count
)
2076 struct lto_file_decl_data
*file_data
= NULL
;
2077 splay_tree file_ids
;
2078 htab_t section_hash_table
;
2079 struct lto_section_slot
*section
;
2080 struct file_data_list file_list
;
2081 struct lto_section_list section_list
;
2083 memset (§ion_list
, 0, sizeof (struct lto_section_list
));
2084 section_hash_table
= lto_obj_build_section_table (file
, §ion_list
);
2086 /* Find all sub modules in the object and put their sections into new hash
2087 tables in a splay tree. */
2088 file_ids
= lto_splay_tree_new ();
2089 memset (&file_list
, 0, sizeof (struct file_data_list
));
2090 for (section
= section_list
.first
; section
!= NULL
; section
= section
->next
)
2091 create_subid_section_table (section
, file_ids
, &file_list
);
2093 /* Add resolutions to file ids */
2094 lto_resolution_read (file_ids
, resolution_file
, file
);
2096 /* Finalize each lto file for each submodule in the merged object */
2097 for (file_data
= file_list
.first
; file_data
!= NULL
; file_data
= file_data
->next
)
2098 lto_create_files_from_ids (file
, file_data
, count
);
2100 splay_tree_delete (file_ids
);
2101 htab_delete (section_hash_table
);
2103 return file_list
.first
;
2106 #if HAVE_MMAP_FILE && HAVE_SYSCONF && defined _SC_PAGE_SIZE
2107 #define LTO_MMAP_IO 1
2111 /* Page size of machine is used for mmap and munmap calls. */
2112 static size_t page_mask
;
2115 /* Get the section data of length LEN from FILENAME starting at
2116 OFFSET. The data segment must be freed by the caller when the
2117 caller is finished. Returns NULL if all was not well. */
2120 lto_read_section_data (struct lto_file_decl_data
*file_data
,
2121 intptr_t offset
, size_t len
)
2125 static char *fd_name
;
2127 intptr_t computed_len
;
2128 intptr_t computed_offset
;
2132 /* Keep a single-entry file-descriptor cache. The last file we
2133 touched will get closed at exit.
2134 ??? Eventually we want to add a more sophisticated larger cache
2135 or rather fix function body streaming to not stream them in
2136 practically random order. */
2138 && filename_cmp (fd_name
, file_data
->file_name
) != 0)
2146 fd
= open (file_data
->file_name
, O_RDONLY
|O_BINARY
);
2149 fatal_error (input_location
, "Cannot open %s", file_data
->file_name
);
2152 fd_name
= xstrdup (file_data
->file_name
);
2158 size_t page_size
= sysconf (_SC_PAGE_SIZE
);
2159 page_mask
= ~(page_size
- 1);
2162 computed_offset
= offset
& page_mask
;
2163 diff
= offset
- computed_offset
;
2164 computed_len
= len
+ diff
;
2166 result
= (char *) mmap (NULL
, computed_len
, PROT_READ
, MAP_PRIVATE
,
2167 fd
, computed_offset
);
2168 if (result
== MAP_FAILED
)
2170 fatal_error (input_location
, "Cannot map %s", file_data
->file_name
);
2174 return result
+ diff
;
2176 result
= (char *) xmalloc (len
);
2177 if (lseek (fd
, offset
, SEEK_SET
) != offset
2178 || read (fd
, result
, len
) != (ssize_t
) len
)
2181 fatal_error (input_location
, "Cannot read %s", file_data
->file_name
);
2185 /* Native windows doesn't supports delayed unlink on opened file. So
2186 we close file here again. This produces higher I/O load, but at least
2187 it prevents to have dangling file handles preventing unlink. */
2198 /* Get the section data from FILE_DATA of SECTION_TYPE with NAME.
2199 NAME will be NULL unless the section type is for a function
2203 get_section_data (struct lto_file_decl_data
*file_data
,
2204 enum lto_section_type section_type
,
2208 htab_t section_hash_table
= file_data
->section_hash_table
;
2209 struct lto_section_slot
*f_slot
;
2210 struct lto_section_slot s_slot
;
2211 const char *section_name
= lto_get_section_name (section_type
, name
, file_data
);
2215 s_slot
.name
= section_name
;
2216 f_slot
= (struct lto_section_slot
*) htab_find (section_hash_table
, &s_slot
);
2219 data
= lto_read_section_data (file_data
, f_slot
->start
, f_slot
->len
);
2223 free (CONST_CAST (char *, section_name
));
2228 /* Free the section data from FILE_DATA of SECTION_TYPE with NAME that
2229 starts at OFFSET and has LEN bytes. */
2232 free_section_data (struct lto_file_decl_data
*file_data ATTRIBUTE_UNUSED
,
2233 enum lto_section_type section_type ATTRIBUTE_UNUSED
,
2234 const char *name ATTRIBUTE_UNUSED
,
2235 const char *offset
, size_t len ATTRIBUTE_UNUSED
)
2238 intptr_t computed_len
;
2239 intptr_t computed_offset
;
2244 computed_offset
= ((intptr_t) offset
) & page_mask
;
2245 diff
= (intptr_t) offset
- computed_offset
;
2246 computed_len
= len
+ diff
;
2248 munmap ((caddr_t
) computed_offset
, computed_len
);
2250 free (CONST_CAST(char *, offset
));
2254 static lto_file
*current_lto_file
;
2256 /* Helper for qsort; compare partitions and return one with smaller size.
2257 We sort from greatest to smallest so parallel build doesn't stale on the
2258 longest compilation being executed too late. */
2261 cmp_partitions_size (const void *a
, const void *b
)
2263 const struct ltrans_partition_def
*pa
2264 = *(struct ltrans_partition_def
*const *)a
;
2265 const struct ltrans_partition_def
*pb
2266 = *(struct ltrans_partition_def
*const *)b
;
2267 return pb
->insns
- pa
->insns
;
2270 /* Helper for qsort; compare partitions and return one with smaller order. */
2273 cmp_partitions_order (const void *a
, const void *b
)
2275 const struct ltrans_partition_def
*pa
2276 = *(struct ltrans_partition_def
*const *)a
;
2277 const struct ltrans_partition_def
*pb
2278 = *(struct ltrans_partition_def
*const *)b
;
2279 int ordera
= -1, orderb
= -1;
2281 if (lto_symtab_encoder_size (pa
->encoder
))
2282 ordera
= lto_symtab_encoder_deref (pa
->encoder
, 0)->order
;
2283 if (lto_symtab_encoder_size (pb
->encoder
))
2284 orderb
= lto_symtab_encoder_deref (pb
->encoder
, 0)->order
;
2285 return orderb
- ordera
;
2288 /* Actually stream out ENCODER into TEMP_FILENAME. */
2291 do_stream_out (char *temp_filename
, lto_symtab_encoder_t encoder
)
2293 lto_file
*file
= lto_obj_file_open (temp_filename
, true);
2295 fatal_error (input_location
, "lto_obj_file_open() failed");
2296 lto_set_current_out_file (file
);
2298 ipa_write_optimization_summaries (encoder
);
2300 lto_set_current_out_file (NULL
);
2301 lto_obj_file_close (file
);
2305 /* Wait for forked process and signal errors. */
2306 #ifdef HAVE_WORKING_FORK
2314 #define WCONTINUED 0
2316 int w
= waitpid (0, &status
, WUNTRACED
| WCONTINUED
);
2318 fatal_error (input_location
, "waitpid failed");
2320 if (WIFEXITED (status
) && WEXITSTATUS (status
))
2321 fatal_error (input_location
, "streaming subprocess failed");
2322 else if (WIFSIGNALED (status
))
2323 fatal_error (input_location
,
2324 "streaming subprocess was killed by signal");
2326 while (!WIFEXITED (status
) && !WIFSIGNALED (status
));
2330 /* Stream out ENCODER into TEMP_FILENAME
2331 Fork if that seems to help. */
2334 stream_out (char *temp_filename
, lto_symtab_encoder_t encoder
,
2335 bool ARG_UNUSED (last
))
2337 #ifdef HAVE_WORKING_FORK
2340 if (lto_parallelism
<= 1)
2342 do_stream_out (temp_filename
, encoder
);
2346 /* Do not run more than LTO_PARALLELISM streamings
2347 FIXME: we ignore limits on jobserver. */
2348 if (lto_parallelism
> 0 && nruns
>= lto_parallelism
)
2353 /* If this is not the last parallel partition, execute new
2354 streaming process. */
2357 pid_t cpid
= fork ();
2361 setproctitle ("lto1-wpa-streaming");
2362 do_stream_out (temp_filename
, encoder
);
2365 /* Fork failed; lets do the job ourseleves. */
2366 else if (cpid
== -1)
2367 do_stream_out (temp_filename
, encoder
);
2371 /* Last partition; stream it and wait for all children to die. */
2375 do_stream_out (temp_filename
, encoder
);
2376 for (i
= 0; i
< nruns
; i
++)
2379 asm_nodes_output
= true;
2381 do_stream_out (temp_filename
, encoder
);
2385 /* Write all output files in WPA mode and the file with the list of
2389 lto_wpa_write_files (void)
2392 ltrans_partition part
;
2393 FILE *ltrans_output_list_stream
;
2394 char *temp_filename
;
2395 vec
<char *>temp_filenames
= vNULL
;
2398 /* Open the LTRANS output list. */
2399 if (!ltrans_output_list
)
2400 fatal_error (input_location
, "no LTRANS output list filename provided");
2402 timevar_push (TV_WHOPR_WPA
);
2404 FOR_EACH_VEC_ELT (ltrans_partitions
, i
, part
)
2405 lto_stats
.num_output_symtab_nodes
+= lto_symtab_encoder_size (part
->encoder
);
2407 timevar_pop (TV_WHOPR_WPA
);
2409 timevar_push (TV_WHOPR_WPA_IO
);
2411 /* Generate a prefix for the LTRANS unit files. */
2412 blen
= strlen (ltrans_output_list
);
2413 temp_filename
= (char *) xmalloc (blen
+ sizeof ("2147483648.o"));
2414 strcpy (temp_filename
, ltrans_output_list
);
2415 if (blen
> sizeof (".out")
2416 && strcmp (temp_filename
+ blen
- sizeof (".out") + 1,
2418 temp_filename
[blen
- sizeof (".out") + 1] = '\0';
2419 blen
= strlen (temp_filename
);
2421 n_sets
= ltrans_partitions
.length ();
2423 /* Sort partitions by size so small ones are compiled last.
2424 FIXME: Even when not reordering we may want to output one list for parallel make
2425 and other for final link command. */
2427 if (!flag_profile_reorder_functions
|| !flag_profile_use
)
2428 ltrans_partitions
.qsort (flag_toplevel_reorder
2429 ? cmp_partitions_size
2430 : cmp_partitions_order
);
2432 for (i
= 0; i
< n_sets
; i
++)
2434 ltrans_partition part
= ltrans_partitions
[i
];
2436 /* Write all the nodes in SET. */
2437 sprintf (temp_filename
+ blen
, "%u.o", i
);
2440 fprintf (stderr
, " %s (%s %i insns)", temp_filename
, part
->name
, part
->insns
);
2441 if (symtab
->dump_file
)
2443 lto_symtab_encoder_iterator lsei
;
2445 fprintf (symtab
->dump_file
, "Writing partition %s to file %s, %i insns\n",
2446 part
->name
, temp_filename
, part
->insns
);
2447 fprintf (symtab
->dump_file
, " Symbols in partition: ");
2448 for (lsei
= lsei_start_in_partition (part
->encoder
); !lsei_end_p (lsei
);
2449 lsei_next_in_partition (&lsei
))
2451 symtab_node
*node
= lsei_node (lsei
);
2452 fprintf (symtab
->dump_file
, "%s ", node
->asm_name ());
2454 fprintf (symtab
->dump_file
, "\n Symbols in boundary: ");
2455 for (lsei
= lsei_start (part
->encoder
); !lsei_end_p (lsei
);
2458 symtab_node
*node
= lsei_node (lsei
);
2459 if (!lto_symtab_encoder_in_partition_p (part
->encoder
, node
))
2461 fprintf (symtab
->dump_file
, "%s ", node
->asm_name ());
2462 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
);
2464 && lto_symtab_encoder_encode_body_p (part
->encoder
, cnode
))
2465 fprintf (symtab
->dump_file
, "(body included)");
2468 varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
);
2470 && lto_symtab_encoder_encode_initializer_p (part
->encoder
, vnode
))
2471 fprintf (symtab
->dump_file
, "(initializer included)");
2475 fprintf (symtab
->dump_file
, "\n");
2477 gcc_checking_assert (lto_symtab_encoder_size (part
->encoder
) || !i
);
2479 stream_out (temp_filename
, part
->encoder
, i
== n_sets
- 1);
2481 part
->encoder
= NULL
;
2483 temp_filenames
.safe_push (xstrdup (temp_filename
));
2485 ltrans_output_list_stream
= fopen (ltrans_output_list
, "w");
2486 if (ltrans_output_list_stream
== NULL
)
2487 fatal_error (input_location
,
2488 "opening LTRANS output list %s: %m", ltrans_output_list
);
2489 for (i
= 0; i
< n_sets
; i
++)
2491 unsigned int len
= strlen (temp_filenames
[i
]);
2492 if (fwrite (temp_filenames
[i
], 1, len
, ltrans_output_list_stream
) < len
2493 || fwrite ("\n", 1, 1, ltrans_output_list_stream
) < 1)
2494 fatal_error (input_location
, "writing to LTRANS output list %s: %m",
2495 ltrans_output_list
);
2496 free (temp_filenames
[i
]);
2498 temp_filenames
.release();
2500 lto_stats
.num_output_files
+= n_sets
;
2502 /* Close the LTRANS output list. */
2503 if (fclose (ltrans_output_list_stream
))
2504 fatal_error (input_location
,
2505 "closing LTRANS output list %s: %m", ltrans_output_list
);
2507 free_ltrans_partitions();
2508 free (temp_filename
);
2510 timevar_pop (TV_WHOPR_WPA_IO
);
2514 /* If TT is a variable or function decl replace it with its
2515 prevailing variant. */
2516 #define LTO_SET_PREVAIL(tt) \
2518 if ((tt) && VAR_OR_FUNCTION_DECL_P (tt) \
2519 && (TREE_PUBLIC (tt) || DECL_EXTERNAL (tt))) \
2521 tt = lto_symtab_prevailing_decl (tt); \
2526 /* Ensure that TT isn't a replacable var of function decl. */
2527 #define LTO_NO_PREVAIL(tt) \
2528 gcc_assert (!(tt) || !VAR_OR_FUNCTION_DECL_P (tt))
2530 /* Given a tree T replace all fields referring to variables or functions
2531 with their prevailing variant. */
2533 lto_fixup_prevailing_decls (tree t
)
2535 enum tree_code code
= TREE_CODE (t
);
2538 gcc_checking_assert (code
!= TREE_BINFO
);
2539 LTO_NO_PREVAIL (TREE_TYPE (t
));
2540 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
2541 LTO_NO_PREVAIL (TREE_CHAIN (t
));
2544 LTO_NO_PREVAIL (DECL_NAME (t
));
2545 LTO_SET_PREVAIL (DECL_CONTEXT (t
));
2546 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
2548 LTO_SET_PREVAIL (DECL_SIZE (t
));
2549 LTO_SET_PREVAIL (DECL_SIZE_UNIT (t
));
2550 LTO_SET_PREVAIL (DECL_INITIAL (t
));
2551 LTO_NO_PREVAIL (DECL_ATTRIBUTES (t
));
2552 LTO_SET_PREVAIL (DECL_ABSTRACT_ORIGIN (t
));
2554 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
2556 LTO_NO_PREVAIL (t
->decl_with_vis
.assembler_name
);
2558 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
2560 LTO_NO_PREVAIL (DECL_RESULT_FLD (t
));
2562 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
2564 LTO_NO_PREVAIL (DECL_ARGUMENTS (t
));
2565 LTO_SET_PREVAIL (DECL_FUNCTION_PERSONALITY (t
));
2566 LTO_NO_PREVAIL (DECL_VINDEX (t
));
2568 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
2570 LTO_SET_PREVAIL (DECL_FIELD_OFFSET (t
));
2571 LTO_NO_PREVAIL (DECL_BIT_FIELD_TYPE (t
));
2572 LTO_NO_PREVAIL (DECL_QUALIFIER (t
));
2573 LTO_NO_PREVAIL (DECL_FIELD_BIT_OFFSET (t
));
2574 LTO_NO_PREVAIL (DECL_FCONTEXT (t
));
2577 else if (TYPE_P (t
))
2579 LTO_NO_PREVAIL (TYPE_CACHED_VALUES (t
));
2580 LTO_SET_PREVAIL (TYPE_SIZE (t
));
2581 LTO_SET_PREVAIL (TYPE_SIZE_UNIT (t
));
2582 LTO_NO_PREVAIL (TYPE_ATTRIBUTES (t
));
2583 LTO_NO_PREVAIL (TYPE_NAME (t
));
2585 LTO_SET_PREVAIL (TYPE_MINVAL (t
));
2586 LTO_SET_PREVAIL (TYPE_MAXVAL (t
));
2587 LTO_NO_PREVAIL (t
->type_non_common
.binfo
);
2589 LTO_SET_PREVAIL (TYPE_CONTEXT (t
));
2591 LTO_NO_PREVAIL (TYPE_CANONICAL (t
));
2592 LTO_NO_PREVAIL (TYPE_MAIN_VARIANT (t
));
2593 LTO_NO_PREVAIL (TYPE_NEXT_VARIANT (t
));
2595 else if (EXPR_P (t
))
2598 for (i
= TREE_OPERAND_LENGTH (t
) - 1; i
>= 0; --i
)
2599 LTO_SET_PREVAIL (TREE_OPERAND (t
, i
));
2601 else if (TREE_CODE (t
) == CONSTRUCTOR
)
2605 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), i
, val
)
2606 LTO_SET_PREVAIL (val
);
2613 LTO_SET_PREVAIL (TREE_VALUE (t
));
2614 LTO_SET_PREVAIL (TREE_PURPOSE (t
));
2615 LTO_NO_PREVAIL (TREE_PURPOSE (t
));
2621 /* If we fixed nothing, then we missed something seen by
2623 gcc_checking_assert (fixed
);
2625 #undef LTO_SET_PREVAIL
2626 #undef LTO_NO_PREVAIL
2628 /* Helper function of lto_fixup_decls. Walks the var and fn streams in STATE,
2629 replaces var and function decls with the corresponding prevailing def. */
2632 lto_fixup_state (struct lto_in_decl_state
*state
)
2636 /* Although we only want to replace FUNCTION_DECLs and VAR_DECLs,
2637 we still need to walk from all DECLs to find the reachable
2638 FUNCTION_DECLs and VAR_DECLs. */
2639 for (si
= 0; si
< LTO_N_DECL_STREAMS
; si
++)
2641 vec
<tree
, va_gc
> *trees
= state
->streams
[si
];
2642 for (i
= 0; i
< vec_safe_length (trees
); i
++)
2644 tree t
= (*trees
)[i
];
2645 #ifdef ENABLE_CHECKING
2649 if (VAR_OR_FUNCTION_DECL_P (t
)
2650 && (TREE_PUBLIC (t
) || DECL_EXTERNAL (t
)))
2651 (*trees
)[i
] = lto_symtab_prevailing_decl (t
);
2656 /* Fix the decls from all FILES. Replaces each decl with the corresponding
2660 lto_fixup_decls (struct lto_file_decl_data
**files
)
2666 FOR_EACH_VEC_ELT ((*tree_with_vars
), i
, t
)
2667 lto_fixup_prevailing_decls (t
);
2669 for (i
= 0; files
[i
]; i
++)
2671 struct lto_file_decl_data
*file
= files
[i
];
2672 struct lto_in_decl_state
*state
= file
->global_decl_state
;
2673 lto_fixup_state (state
);
2675 hash_table
<decl_state_hasher
>::iterator iter
;
2676 lto_in_decl_state
*elt
;
2677 FOR_EACH_HASH_TABLE_ELEMENT (*file
->function_decl_states
, elt
,
2678 lto_in_decl_state
*, iter
)
2679 lto_fixup_state (elt
);
2683 static GTY((length ("lto_stats.num_input_files + 1"))) struct lto_file_decl_data
**all_file_decl_data
;
2685 /* Turn file datas for sub files into a single array, so that they look
2686 like separate files for further passes. */
2689 lto_flatten_files (struct lto_file_decl_data
**orig
, int count
, int last_file_ix
)
2691 struct lto_file_decl_data
*n
, *next
;
2694 lto_stats
.num_input_files
= count
;
2696 = ggc_cleared_vec_alloc
<lto_file_decl_data_ptr
> (count
+ 1);
2697 /* Set the hooks so that all of the ipa passes can read in their data. */
2698 lto_set_in_hooks (all_file_decl_data
, get_section_data
, free_section_data
);
2699 for (i
= 0, k
= 0; i
< last_file_ix
; i
++)
2701 for (n
= orig
[i
]; n
!= NULL
; n
= next
)
2703 all_file_decl_data
[k
++] = n
;
2708 all_file_decl_data
[k
] = NULL
;
2709 gcc_assert (k
== count
);
2712 /* Input file data before flattening (i.e. splitting them to subfiles to support
2713 incremental linking. */
2714 static int real_file_count
;
2715 static GTY((length ("real_file_count + 1"))) struct lto_file_decl_data
**real_file_decl_data
;
2717 static void print_lto_report_1 (void);
2719 /* Read all the symbols from the input files FNAMES. NFILES is the
2720 number of files requested in the command line. Instantiate a
2721 global call graph by aggregating all the sub-graphs found in each
2725 read_cgraph_and_symbols (unsigned nfiles
, const char **fnames
)
2727 unsigned int i
, last_file_ix
;
2730 struct lto_file_decl_data
**decl_data
;
2733 symtab
->initialize ();
2735 timevar_push (TV_IPA_LTO_DECL_IN
);
2737 #ifdef ACCEL_COMPILER
2738 section_name_prefix
= OFFLOAD_SECTION_NAME_PREFIX
;
2739 lto_stream_offload_p
= true;
2743 = decl_data
= ggc_cleared_vec_alloc
<lto_file_decl_data_ptr
> (nfiles
+ 1);
2744 real_file_count
= nfiles
;
2746 /* Read the resolution file. */
2748 if (resolution_file_name
)
2751 unsigned num_objects
;
2753 resolution
= fopen (resolution_file_name
, "r");
2754 if (resolution
== NULL
)
2755 fatal_error (input_location
,
2756 "could not open symbol resolution file: %m");
2758 t
= fscanf (resolution
, "%u", &num_objects
);
2759 gcc_assert (t
== 1);
2761 /* True, since the plugin splits the archives. */
2762 gcc_assert (num_objects
== nfiles
);
2764 symtab
->state
= LTO_STREAMING
;
2766 canonical_type_hash_cache
= new hash_map
<const_tree
, hashval_t
> (251);
2767 gimple_canonical_types
= htab_create (16381, gimple_canonical_type_hash
,
2768 gimple_canonical_type_eq
, NULL
);
2769 gcc_obstack_init (&tree_scc_hash_obstack
);
2770 tree_scc_hash
= new hash_table
<tree_scc_hasher
> (4096);
2772 /* Register the common node types with the canonical type machinery so
2773 we properly share alias-sets across languages and TUs. Do not
2774 expose the common nodes as type merge target - those that should be
2775 are already exposed so by pre-loading the LTO streamer caches.
2776 Do two passes - first clear TYPE_CANONICAL and then re-compute it. */
2777 for (i
= 0; i
< itk_none
; ++i
)
2778 lto_register_canonical_types (integer_types
[i
], true);
2779 for (i
= 0; i
< stk_type_kind_last
; ++i
)
2780 lto_register_canonical_types (sizetype_tab
[i
], true);
2781 for (i
= 0; i
< TI_MAX
; ++i
)
2782 lto_register_canonical_types (global_trees
[i
], true);
2783 for (i
= 0; i
< itk_none
; ++i
)
2784 lto_register_canonical_types (integer_types
[i
], false);
2785 for (i
= 0; i
< stk_type_kind_last
; ++i
)
2786 lto_register_canonical_types (sizetype_tab
[i
], false);
2787 for (i
= 0; i
< TI_MAX
; ++i
)
2788 lto_register_canonical_types (global_trees
[i
], false);
2791 fprintf (stderr
, "Reading object files:");
2793 /* Read all of the object files specified on the command line. */
2794 for (i
= 0, last_file_ix
= 0; i
< nfiles
; ++i
)
2796 struct lto_file_decl_data
*file_data
= NULL
;
2799 fprintf (stderr
, " %s", fnames
[i
]);
2803 current_lto_file
= lto_obj_file_open (fnames
[i
], false);
2804 if (!current_lto_file
)
2807 file_data
= lto_file_read (current_lto_file
, resolution
, &count
);
2810 lto_obj_file_close (current_lto_file
);
2811 free (current_lto_file
);
2812 current_lto_file
= NULL
;
2816 decl_data
[last_file_ix
++] = file_data
;
2818 lto_obj_file_close (current_lto_file
);
2819 free (current_lto_file
);
2820 current_lto_file
= NULL
;
2823 lto_flatten_files (decl_data
, count
, last_file_ix
);
2824 lto_stats
.num_input_files
= count
;
2825 ggc_free(decl_data
);
2826 real_file_decl_data
= NULL
;
2828 if (resolution_file_name
)
2829 fclose (resolution
);
2831 /* Show the LTO report before launching LTRANS. */
2832 if (flag_lto_report
|| (flag_wpa
&& flag_lto_report_wpa
))
2833 print_lto_report_1 ();
2835 /* Free gimple type merging datastructures. */
2836 delete tree_scc_hash
;
2837 tree_scc_hash
= NULL
;
2838 obstack_free (&tree_scc_hash_obstack
, NULL
);
2839 htab_delete (gimple_canonical_types
);
2840 gimple_canonical_types
= NULL
;
2841 delete canonical_type_hash_cache
;
2842 canonical_type_hash_cache
= NULL
;
2844 /* At this stage we know that majority of GGC memory is reachable.
2845 Growing the limits prevents unnecesary invocation of GGC. */
2849 /* Set the hooks so that all of the ipa passes can read in their data. */
2850 lto_set_in_hooks (all_file_decl_data
, get_section_data
, free_section_data
);
2852 timevar_pop (TV_IPA_LTO_DECL_IN
);
2855 fprintf (stderr
, "\nReading the callgraph\n");
2857 timevar_push (TV_IPA_LTO_CGRAPH_IO
);
2858 /* Read the symtab. */
2861 input_offload_tables ();
2863 /* Store resolutions into the symbol table. */
2865 ld_plugin_symbol_resolution_t
*res
;
2866 FOR_EACH_SYMBOL (snode
)
2867 if (snode
->real_symbol_p ()
2868 && snode
->lto_file_data
2869 && snode
->lto_file_data
->resolution_map
2870 && (res
= snode
->lto_file_data
->resolution_map
->get (snode
->decl
)))
2871 snode
->resolution
= *res
;
2872 for (i
= 0; all_file_decl_data
[i
]; i
++)
2873 if (all_file_decl_data
[i
]->resolution_map
)
2875 delete all_file_decl_data
[i
]->resolution_map
;
2876 all_file_decl_data
[i
]->resolution_map
= NULL
;
2879 timevar_pop (TV_IPA_LTO_CGRAPH_IO
);
2882 fprintf (stderr
, "Merging declarations\n");
2884 timevar_push (TV_IPA_LTO_DECL_MERGE
);
2885 /* Merge global decls. In ltrans mode we read merged cgraph, we do not
2886 need to care about resolving symbols again, we only need to replace
2887 duplicated declarations read from the callgraph and from function
2891 lto_symtab_merge_decls ();
2893 /* If there were errors during symbol merging bail out, we have no
2894 good way to recover here. */
2896 fatal_error (input_location
,
2897 "errors during merging of translation units");
2899 /* Fixup all decls. */
2900 lto_fixup_decls (all_file_decl_data
);
2903 ggc_free (tree_with_vars
);
2904 tree_with_vars
= NULL
;
2907 timevar_pop (TV_IPA_LTO_DECL_MERGE
);
2908 /* Each pass will set the appropriate timer. */
2911 fprintf (stderr
, "Reading summaries\n");
2913 /* Read the IPA summary data. */
2915 ipa_read_optimization_summaries ();
2917 ipa_read_summaries ();
2919 for (i
= 0; all_file_decl_data
[i
]; i
++)
2921 gcc_assert (all_file_decl_data
[i
]->symtab_node_encoder
);
2922 lto_symtab_encoder_delete (all_file_decl_data
[i
]->symtab_node_encoder
);
2923 all_file_decl_data
[i
]->symtab_node_encoder
= NULL
;
2924 lto_free_function_in_decl_state (all_file_decl_data
[i
]->global_decl_state
);
2925 all_file_decl_data
[i
]->global_decl_state
= NULL
;
2926 all_file_decl_data
[i
]->current_decl_state
= NULL
;
2929 /* Finally merge the cgraph according to the decl merging decisions. */
2930 timevar_push (TV_IPA_LTO_CGRAPH_MERGE
);
2931 if (symtab
->dump_file
)
2933 fprintf (symtab
->dump_file
, "Before merging:\n");
2934 symtab_node::dump_table (symtab
->dump_file
);
2938 lto_symtab_merge_symbols ();
2939 /* Removal of unreachable symbols is needed to make verify_symtab to pass;
2940 we are still having duplicated comdat groups containing local statics.
2941 We could also just remove them while merging. */
2942 symtab
->remove_unreachable_nodes (dump_file
);
2945 symtab
->state
= IPA_SSA
;
2946 /* FIXME: Technically all node removals happening here are useless, because
2947 WPA should not stream them. */
2949 symtab
->remove_unreachable_nodes (dump_file
);
2951 timevar_pop (TV_IPA_LTO_CGRAPH_MERGE
);
2953 /* Indicate that the cgraph is built and ready. */
2954 symtab
->function_flags_ready
= true;
2956 ggc_free (all_file_decl_data
);
2957 all_file_decl_data
= NULL
;
2961 /* Materialize all the bodies for all the nodes in the callgraph. */
2964 materialize_cgraph (void)
2966 struct cgraph_node
*node
;
2967 timevar_id_t lto_timer
;
2971 flag_wpa
? "Materializing decls:" : "Reading function bodies:");
2974 FOR_EACH_FUNCTION (node
)
2976 if (node
->lto_file_data
)
2978 lto_materialize_function (node
);
2979 lto_stats
.num_input_cgraph_nodes
++;
2984 /* Start the appropriate timer depending on the mode that we are
2986 lto_timer
= (flag_wpa
) ? TV_WHOPR_WPA
2987 : (flag_ltrans
) ? TV_WHOPR_LTRANS
2989 timevar_push (lto_timer
);
2991 current_function_decl
= NULL
;
2995 fprintf (stderr
, "\n");
2997 timevar_pop (lto_timer
);
3001 /* Show various memory usage statistics related to LTO. */
3003 print_lto_report_1 (void)
3005 const char *pfx
= (flag_lto
) ? "LTO" : (flag_wpa
) ? "WPA" : "LTRANS";
3006 fprintf (stderr
, "%s statistics\n", pfx
);
3008 fprintf (stderr
, "[%s] read %lu SCCs of average size %f\n",
3009 pfx
, num_sccs_read
, total_scc_size
/ (double)num_sccs_read
);
3010 fprintf (stderr
, "[%s] %lu tree bodies read in total\n", pfx
, total_scc_size
);
3011 if (flag_wpa
&& tree_scc_hash
)
3013 fprintf (stderr
, "[%s] tree SCC table: size %ld, %ld elements, "
3014 "collision ratio: %f\n", pfx
,
3015 (long) tree_scc_hash
->size (),
3016 (long) tree_scc_hash
->elements (),
3017 tree_scc_hash
->collisions ());
3018 hash_table
<tree_scc_hasher
>::iterator hiter
;
3019 tree_scc
*scc
, *max_scc
= NULL
;
3020 unsigned max_length
= 0;
3021 FOR_EACH_HASH_TABLE_ELEMENT (*tree_scc_hash
, scc
, x
, hiter
)
3023 unsigned length
= 0;
3025 for (; s
; s
= s
->next
)
3027 if (length
> max_length
)
3029 max_length
= length
;
3033 fprintf (stderr
, "[%s] tree SCC max chain length %u (size %u)\n",
3034 pfx
, max_length
, max_scc
->len
);
3035 fprintf (stderr
, "[%s] Compared %lu SCCs, %lu collisions (%f)\n", pfx
,
3036 num_scc_compares
, num_scc_compare_collisions
,
3037 num_scc_compare_collisions
/ (double) num_scc_compares
);
3038 fprintf (stderr
, "[%s] Merged %lu SCCs\n", pfx
, num_sccs_merged
);
3039 fprintf (stderr
, "[%s] Merged %lu tree bodies\n", pfx
,
3040 total_scc_size_merged
);
3041 fprintf (stderr
, "[%s] Merged %lu types\n", pfx
, num_merged_types
);
3042 fprintf (stderr
, "[%s] %lu types prevailed (%lu associated trees)\n",
3043 pfx
, num_prevailing_types
, num_type_scc_trees
);
3044 fprintf (stderr
, "[%s] GIMPLE canonical type table: size %ld, "
3045 "%ld elements, %ld searches, %ld collisions (ratio: %f)\n", pfx
,
3046 (long) htab_size (gimple_canonical_types
),
3047 (long) htab_elements (gimple_canonical_types
),
3048 (long) gimple_canonical_types
->searches
,
3049 (long) gimple_canonical_types
->collisions
,
3050 htab_collisions (gimple_canonical_types
));
3051 fprintf (stderr
, "[%s] GIMPLE canonical type pointer-map: "
3052 "%lu elements, %ld searches\n", pfx
,
3053 num_canonical_type_hash_entries
,
3054 num_canonical_type_hash_queries
);
3057 print_lto_report (pfx
);
3060 /* Perform whole program analysis (WPA) on the callgraph and write out the
3061 optimization plan. */
3064 do_whole_program_analysis (void)
3068 lto_parallelism
= 1;
3070 /* TODO: jobserver communicatoin is not supported, yet. */
3071 if (!strcmp (flag_wpa
, "jobserver"))
3072 lto_parallelism
= -1;
3075 lto_parallelism
= atoi (flag_wpa
);
3076 if (lto_parallelism
<= 0)
3077 lto_parallelism
= 0;
3080 timevar_start (TV_PHASE_OPT_GEN
);
3082 /* Note that since we are in WPA mode, materialize_cgraph will not
3083 actually read in all the function bodies. It only materializes
3084 the decls and cgraph nodes so that analysis can be performed. */
3085 materialize_cgraph ();
3087 /* Reading in the cgraph uses different timers, start timing WPA now. */
3088 timevar_push (TV_WHOPR_WPA
);
3090 if (pre_ipa_mem_report
)
3092 fprintf (stderr
, "Memory consumption before IPA\n");
3093 dump_memory_report (false);
3096 symtab
->function_flags_ready
= true;
3098 if (symtab
->dump_file
)
3099 symtab_node::dump_table (symtab
->dump_file
);
3100 bitmap_obstack_initialize (NULL
);
3101 symtab
->state
= IPA_SSA
;
3103 execute_ipa_pass_list (g
->get_passes ()->all_regular_ipa_passes
);
3105 if (symtab
->dump_file
)
3107 fprintf (symtab
->dump_file
, "Optimized ");
3108 symtab_node::dump_table (symtab
->dump_file
);
3110 #ifdef ENABLE_CHECKING
3111 symtab_node::verify_symtab_nodes ();
3113 bitmap_obstack_release (NULL
);
3115 /* We are about to launch the final LTRANS phase, stop the WPA timer. */
3116 timevar_pop (TV_WHOPR_WPA
);
3118 timevar_push (TV_WHOPR_PARTITIONING
);
3119 if (flag_lto_partition
== LTO_PARTITION_1TO1
)
3121 else if (flag_lto_partition
== LTO_PARTITION_MAX
)
3123 else if (flag_lto_partition
== LTO_PARTITION_ONE
)
3124 lto_balanced_map (1);
3125 else if (flag_lto_partition
== LTO_PARTITION_BALANCED
)
3126 lto_balanced_map (PARAM_VALUE (PARAM_LTO_PARTITIONS
));
3130 /* Inline summaries are needed for balanced partitioning. Free them now so
3131 the memory can be used for streamer caches. */
3132 inline_free_summary ();
3134 /* AUX pointers are used by partitioning code to bookkeep number of
3135 partitions symbol is in. This is no longer needed. */
3136 FOR_EACH_SYMBOL (node
)
3139 lto_stats
.num_cgraph_partitions
+= ltrans_partitions
.length ();
3141 /* Find out statics that need to be promoted
3142 to globals with hidden visibility because they are accessed from multiple
3144 lto_promote_cross_file_statics ();
3145 timevar_pop (TV_WHOPR_PARTITIONING
);
3147 timevar_stop (TV_PHASE_OPT_GEN
);
3149 /* Collect a last time - in lto_wpa_write_files we may end up forking
3150 with the idea that this doesn't increase memory usage. So we
3151 absoultely do not want to collect after that. */
3154 timevar_start (TV_PHASE_STREAM_OUT
);
3157 fprintf (stderr
, "\nStreaming out");
3160 lto_wpa_write_files ();
3162 fprintf (stderr
, "\n");
3163 timevar_stop (TV_PHASE_STREAM_OUT
);
3165 if (post_ipa_mem_report
)
3167 fprintf (stderr
, "Memory consumption after IPA\n");
3168 dump_memory_report (false);
3171 /* Show the LTO report before launching LTRANS. */
3172 if (flag_lto_report
|| (flag_wpa
&& flag_lto_report_wpa
))
3173 print_lto_report_1 ();
3175 dump_memory_report (true);
3179 static GTY(()) tree lto_eh_personality_decl
;
3181 /* Return the LTO personality function decl. */
3184 lto_eh_personality (void)
3186 if (!lto_eh_personality_decl
)
3188 /* Use the first personality DECL for our personality if we don't
3189 support multiple ones. This ensures that we don't artificially
3190 create the need for them in a single-language program. */
3191 if (first_personality_decl
&& !dwarf2out_do_cfi_asm ())
3192 lto_eh_personality_decl
= first_personality_decl
;
3194 lto_eh_personality_decl
= lhd_gcc_personality ();
3197 return lto_eh_personality_decl
;
3200 /* Set the process name based on the LTO mode. */
3203 lto_process_name (void)
3206 setproctitle ("lto1-lto");
3208 setproctitle ("lto1-wpa");
3210 setproctitle ("lto1-ltrans");
3214 /* Initialize the LTO front end. */
3219 lto_process_name ();
3220 lto_streamer_hooks_init ();
3222 lto_set_in_hooks (NULL
, get_section_data
, free_section_data
);
3223 memset (<o_stats
, 0, sizeof (lto_stats
));
3224 bitmap_obstack_initialize (NULL
);
3225 gimple_register_cfg_hooks ();
3226 #ifndef ACCEL_COMPILER
3227 unsigned char *table
3228 = ggc_vec_alloc
<unsigned char> (MAX_MACHINE_MODE
);
3229 for (int m
= 0; m
< MAX_MACHINE_MODE
; m
++)
3231 lto_mode_identity_table
= table
;
3236 /* Main entry point for the GIMPLE front end. This front end has
3237 three main personalities:
3239 - LTO (-flto). All the object files on the command line are
3240 loaded in memory and processed as a single translation unit.
3241 This is the traditional link-time optimization behavior.
3243 - WPA (-fwpa). Only the callgraph and summary information for
3244 files in the command file are loaded. A single callgraph
3245 (without function bodies) is instantiated for the whole set of
3246 files. IPA passes are only allowed to analyze the call graph
3247 and make transformation decisions. The callgraph is
3248 partitioned, each partition is written to a new object file
3249 together with the transformation decisions.
3251 - LTRANS (-fltrans). Similar to -flto but it prevents the IPA
3252 summary files from running again. Since WPA computed summary
3253 information and decided what transformations to apply, LTRANS
3254 simply applies them. */
3259 /* LTO is called as a front end, even though it is not a front end.
3260 Because it is called as a front end, TV_PHASE_PARSING and
3261 TV_PARSE_GLOBAL are active, and we need to turn them off while
3262 doing LTO. Later we turn them back on so they are active up in
3264 timevar_pop (TV_PARSE_GLOBAL
);
3265 timevar_stop (TV_PHASE_PARSING
);
3267 timevar_start (TV_PHASE_SETUP
);
3269 /* Initialize the LTO front end. */
3272 timevar_stop (TV_PHASE_SETUP
);
3273 timevar_start (TV_PHASE_STREAM_IN
);
3275 /* Read all the symbols and call graph from all the files in the
3277 read_cgraph_and_symbols (num_in_fnames
, in_fnames
);
3279 timevar_stop (TV_PHASE_STREAM_IN
);
3283 /* If WPA is enabled analyze the whole call graph and create an
3284 optimization plan. Otherwise, read in all the function
3285 bodies and continue with optimization. */
3287 do_whole_program_analysis ();
3290 timevar_start (TV_PHASE_OPT_GEN
);
3292 materialize_cgraph ();
3294 lto_promote_statics_nonwpa ();
3296 /* Let the middle end know that we have read and merged all of
3300 timevar_stop (TV_PHASE_OPT_GEN
);
3302 /* FIXME lto, if the processes spawned by WPA fail, we miss
3303 the chance to print WPA's report, so WPA will call
3304 print_lto_report before launching LTRANS. If LTRANS was
3305 launched directly by the driver we would not need to do
3307 if (flag_lto_report
|| (flag_wpa
&& flag_lto_report_wpa
))
3308 print_lto_report_1 ();
3312 /* Here we make LTO pretend to be a parser. */
3313 timevar_start (TV_PHASE_PARSING
);
3314 timevar_push (TV_PARSE_GLOBAL
);
3317 #include "gt-lto-lto.h"