1 /* Top-level LTO routines.
2 Copyright (C) 2009-2016 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"
53 #include "stringpool.h"
54 #include "fold-const.h"
57 /* Number of parallel tasks to run, -1 if we want to use GNU Make jobserver. */
58 static int lto_parallelism
;
60 static GTY(()) tree first_personality_decl
;
62 static GTY(()) const unsigned char *lto_mode_identity_table
;
64 /* Returns a hash code for P. */
67 hash_name (const void *p
)
69 const struct lto_section_slot
*ds
= (const struct lto_section_slot
*) p
;
70 return (hashval_t
) htab_hash_string (ds
->name
);
74 /* Returns nonzero if P1 and P2 are equal. */
77 eq_name (const void *p1
, const void *p2
)
79 const struct lto_section_slot
*s1
=
80 (const struct lto_section_slot
*) p1
;
81 const struct lto_section_slot
*s2
=
82 (const struct lto_section_slot
*) p2
;
84 return strcmp (s1
->name
, s2
->name
) == 0;
87 /* Free lto_section_slot */
90 free_with_string (void *arg
)
92 struct lto_section_slot
*s
= (struct lto_section_slot
*)arg
;
94 free (CONST_CAST (char *, s
->name
));
98 /* Create section hash table */
101 lto_obj_create_section_hash_table (void)
103 return htab_create (37, hash_name
, eq_name
, free_with_string
);
106 /* Delete an allocated integer KEY in the splay tree. */
109 lto_splay_tree_delete_id (splay_tree_key key
)
114 /* Compare splay tree node ids A and B. */
117 lto_splay_tree_compare_ids (splay_tree_key a
, splay_tree_key b
)
119 unsigned HOST_WIDE_INT ai
;
120 unsigned HOST_WIDE_INT bi
;
122 ai
= *(unsigned HOST_WIDE_INT
*) a
;
123 bi
= *(unsigned HOST_WIDE_INT
*) b
;
132 /* Look up splay tree node by ID in splay tree T. */
134 static splay_tree_node
135 lto_splay_tree_lookup (splay_tree t
, unsigned HOST_WIDE_INT id
)
137 return splay_tree_lookup (t
, (splay_tree_key
) &id
);
140 /* Check if KEY has ID. */
143 lto_splay_tree_id_equal_p (splay_tree_key key
, unsigned HOST_WIDE_INT id
)
145 return *(unsigned HOST_WIDE_INT
*) key
== id
;
148 /* Insert a splay tree node into tree T with ID as key and FILE_DATA as value.
149 The ID is allocated separately because we need HOST_WIDE_INTs which may
150 be wider than a splay_tree_key. */
153 lto_splay_tree_insert (splay_tree t
, unsigned HOST_WIDE_INT id
,
154 struct lto_file_decl_data
*file_data
)
156 unsigned HOST_WIDE_INT
*idp
= XCNEW (unsigned HOST_WIDE_INT
);
158 splay_tree_insert (t
, (splay_tree_key
) idp
, (splay_tree_value
) file_data
);
161 /* Create a splay tree. */
164 lto_splay_tree_new (void)
166 return splay_tree_new (lto_splay_tree_compare_ids
,
167 lto_splay_tree_delete_id
,
171 /* Return true when NODE has a clone that is analyzed (i.e. we need
172 to load its body even if the node itself is not needed). */
175 has_analyzed_clone_p (struct cgraph_node
*node
)
177 struct cgraph_node
*orig
= node
;
186 else if (node
->next_sibling_clone
)
187 node
= node
->next_sibling_clone
;
190 while (node
!= orig
&& !node
->next_sibling_clone
)
191 node
= node
->clone_of
;
193 node
= node
->next_sibling_clone
;
199 /* Read the function body for the function associated with NODE. */
202 lto_materialize_function (struct cgraph_node
*node
)
207 /* Read in functions with body (analyzed nodes)
208 and also functions that are needed to produce virtual clones. */
209 if ((node
->has_gimple_body_p () && node
->analyzed
)
210 || node
->used_as_abstract_origin
211 || has_analyzed_clone_p (node
))
213 /* Clones don't need to be read. */
216 if (DECL_FUNCTION_PERSONALITY (decl
) && !first_personality_decl
)
217 first_personality_decl
= DECL_FUNCTION_PERSONALITY (decl
);
220 /* Let the middle end know about the function. */
221 rest_of_decl_compilation (decl
, 1, 0);
225 /* Decode the content of memory pointed to by DATA in the in decl
226 state object STATE. DATA_IN points to a data_in structure for
227 decoding. Return the address after the decoded object in the
230 static const uint32_t *
231 lto_read_in_decl_state (struct data_in
*data_in
, const uint32_t *data
,
232 struct lto_in_decl_state
*state
)
239 state
->compressed
= ix
& 1;
241 decl
= streamer_tree_cache_get_tree (data_in
->reader_cache
, ix
);
242 if (!VAR_OR_FUNCTION_DECL_P (decl
))
244 gcc_assert (decl
== void_type_node
);
247 state
->fn_decl
= decl
;
249 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
251 uint32_t size
= *data
++;
252 vec
<tree
, va_gc
> *decls
= NULL
;
253 vec_alloc (decls
, size
);
255 for (j
= 0; j
< size
; j
++)
256 vec_safe_push (decls
,
257 streamer_tree_cache_get_tree (data_in
->reader_cache
,
260 state
->streams
[i
] = decls
;
268 /* Global canonical type table. */
269 static htab_t gimple_canonical_types
;
270 static hash_map
<const_tree
, hashval_t
> *canonical_type_hash_cache
;
271 static unsigned long num_canonical_type_hash_entries
;
272 static unsigned long num_canonical_type_hash_queries
;
274 static void iterative_hash_canonical_type (tree type
, inchash::hash
&hstate
);
275 static hashval_t
gimple_canonical_type_hash (const void *p
);
276 static void gimple_register_canonical_type_1 (tree t
, hashval_t hash
);
278 /* Returning a hash value for gimple type TYPE.
280 The hash value returned is equal for types considered compatible
281 by gimple_canonical_types_compatible_p. */
284 hash_canonical_type (tree type
)
286 inchash::hash hstate
;
289 /* We compute alias sets only for types that needs them.
290 Be sure we do not recurse to something else as we can not hash incomplete
291 types in a way they would have same hash value as compatible complete
293 gcc_checking_assert (type_with_alias_set_p (type
));
295 /* Combine a few common features of types so that types are grouped into
296 smaller sets; when searching for existing matching types to merge,
297 only existing types having the same features as the new type will be
299 code
= tree_code_for_canonical_type_merging (TREE_CODE (type
));
300 hstate
.add_int (code
);
301 hstate
.add_int (TYPE_MODE (type
));
303 /* Incorporate common features of numerical types. */
304 if (INTEGRAL_TYPE_P (type
)
305 || SCALAR_FLOAT_TYPE_P (type
)
306 || FIXED_POINT_TYPE_P (type
)
307 || TREE_CODE (type
) == OFFSET_TYPE
308 || POINTER_TYPE_P (type
))
310 hstate
.add_int (TYPE_PRECISION (type
));
311 if (!type_with_interoperable_signedness (type
))
312 hstate
.add_int (TYPE_UNSIGNED (type
));
315 if (VECTOR_TYPE_P (type
))
317 hstate
.add_int (TYPE_VECTOR_SUBPARTS (type
));
318 hstate
.add_int (TYPE_UNSIGNED (type
));
321 if (TREE_CODE (type
) == COMPLEX_TYPE
)
322 hstate
.add_int (TYPE_UNSIGNED (type
));
324 /* Fortran's C_SIGNED_CHAR is !TYPE_STRING_FLAG but needs to be
325 interoperable with "signed char". Unless all frontends are revisited to
326 agree on these types, we must ignore the flag completely. */
328 /* Fortran standard define C_PTR type that is compatible with every
329 C pointer. For this reason we need to glob all pointers into one.
330 Still pointers in different address spaces are not compatible. */
331 if (POINTER_TYPE_P (type
))
332 hstate
.add_int (TYPE_ADDR_SPACE (TREE_TYPE (type
)));
334 /* For array types hash the domain bounds and the string flag. */
335 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
337 hstate
.add_int (TYPE_STRING_FLAG (type
));
338 /* OMP lowering can introduce error_mark_node in place of
339 random local decls in types. */
340 if (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)) != error_mark_node
)
341 inchash::add_expr (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)), hstate
);
342 if (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != error_mark_node
)
343 inchash::add_expr (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)), hstate
);
346 /* Recurse for aggregates with a single element type. */
347 if (TREE_CODE (type
) == ARRAY_TYPE
348 || TREE_CODE (type
) == COMPLEX_TYPE
349 || TREE_CODE (type
) == VECTOR_TYPE
)
350 iterative_hash_canonical_type (TREE_TYPE (type
), hstate
);
352 /* Incorporate function return and argument types. */
353 if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
358 iterative_hash_canonical_type (TREE_TYPE (type
), hstate
);
360 for (p
= TYPE_ARG_TYPES (type
), na
= 0; p
; p
= TREE_CHAIN (p
))
362 iterative_hash_canonical_type (TREE_VALUE (p
), hstate
);
369 if (RECORD_OR_UNION_TYPE_P (type
))
374 for (f
= TYPE_FIELDS (type
), nf
= 0; f
; f
= TREE_CHAIN (f
))
375 if (TREE_CODE (f
) == FIELD_DECL
)
377 iterative_hash_canonical_type (TREE_TYPE (f
), hstate
);
387 /* Returning a hash value for gimple type TYPE combined with VAL. */
390 iterative_hash_canonical_type (tree type
, inchash::hash
&hstate
)
394 /* All type variants have same TYPE_CANONICAL. */
395 type
= TYPE_MAIN_VARIANT (type
);
397 if (!canonical_type_used_p (type
))
398 v
= hash_canonical_type (type
);
399 /* An already processed type. */
400 else if (TYPE_CANONICAL (type
))
402 type
= TYPE_CANONICAL (type
);
403 v
= gimple_canonical_type_hash (type
);
407 /* Canonical types should not be able to form SCCs by design, this
408 recursion is just because we do not register canonical types in
409 optimal order. To avoid quadratic behavior also register the
411 v
= hash_canonical_type (type
);
412 gimple_register_canonical_type_1 (type
, v
);
417 /* Returns the hash for a canonical type P. */
420 gimple_canonical_type_hash (const void *p
)
422 num_canonical_type_hash_queries
++;
423 hashval_t
*slot
= canonical_type_hash_cache
->get ((const_tree
) p
);
424 gcc_assert (slot
!= NULL
);
430 /* Returns nonzero if P1 and P2 are equal. */
433 gimple_canonical_type_eq (const void *p1
, const void *p2
)
435 const_tree t1
= (const_tree
) p1
;
436 const_tree t2
= (const_tree
) p2
;
437 return gimple_canonical_types_compatible_p (CONST_CAST_TREE (t1
),
438 CONST_CAST_TREE (t2
));
441 /* Main worker for gimple_register_canonical_type. */
444 gimple_register_canonical_type_1 (tree t
, hashval_t hash
)
448 gcc_checking_assert (TYPE_P (t
) && !TYPE_CANONICAL (t
)
449 && type_with_alias_set_p (t
)
450 && canonical_type_used_p (t
));
452 slot
= htab_find_slot_with_hash (gimple_canonical_types
, t
, hash
, INSERT
);
455 tree new_type
= (tree
)(*slot
);
456 gcc_checking_assert (new_type
!= t
);
457 TYPE_CANONICAL (t
) = new_type
;
461 TYPE_CANONICAL (t
) = t
;
463 /* Cache the just computed hash value. */
464 num_canonical_type_hash_entries
++;
465 bool existed_p
= canonical_type_hash_cache
->put (t
, hash
);
466 gcc_assert (!existed_p
);
470 /* Register type T in the global type table gimple_types and set
471 TYPE_CANONICAL of T accordingly.
472 This is used by LTO to merge structurally equivalent types for
473 type-based aliasing purposes across different TUs and languages.
475 ??? This merging does not exactly match how the tree.c middle-end
476 functions will assign TYPE_CANONICAL when new types are created
477 during optimization (which at least happens for pointer and array
481 gimple_register_canonical_type (tree t
)
483 if (TYPE_CANONICAL (t
) || !type_with_alias_set_p (t
)
484 || !canonical_type_used_p (t
))
487 /* Canonical types are same among all complete variants. */
488 if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (t
)))
489 TYPE_CANONICAL (t
) = TYPE_CANONICAL (TYPE_MAIN_VARIANT (t
));
492 gimple_register_canonical_type_1 (TYPE_MAIN_VARIANT (t
),
493 hash_canonical_type (TYPE_MAIN_VARIANT (t
)));
494 TYPE_CANONICAL (t
) = TYPE_CANONICAL (TYPE_MAIN_VARIANT (t
));
498 /* Re-compute TYPE_CANONICAL for NODE and related types. */
501 lto_register_canonical_types (tree node
, bool first_p
)
508 TYPE_CANONICAL (node
) = NULL_TREE
;
510 if (POINTER_TYPE_P (node
)
511 || TREE_CODE (node
) == COMPLEX_TYPE
512 || TREE_CODE (node
) == ARRAY_TYPE
)
513 lto_register_canonical_types (TREE_TYPE (node
), first_p
);
516 gimple_register_canonical_type (node
);
520 /* Remember trees that contains references to declarations. */
521 static GTY(()) vec
<tree
, va_gc
> *tree_with_vars
;
523 #define CHECK_VAR(tt) \
526 if ((tt) && VAR_OR_FUNCTION_DECL_P (tt) \
527 && (TREE_PUBLIC (tt) || DECL_EXTERNAL (tt))) \
531 #define CHECK_NO_VAR(tt) \
532 gcc_checking_assert (!(tt) || !VAR_OR_FUNCTION_DECL_P (tt))
534 /* Check presence of pointers to decls in fields of a tree_typed T. */
537 mentions_vars_p_typed (tree t
)
539 CHECK_NO_VAR (TREE_TYPE (t
));
543 /* Check presence of pointers to decls in fields of a tree_common T. */
546 mentions_vars_p_common (tree t
)
548 if (mentions_vars_p_typed (t
))
550 CHECK_NO_VAR (TREE_CHAIN (t
));
554 /* Check presence of pointers to decls in fields of a decl_minimal T. */
557 mentions_vars_p_decl_minimal (tree t
)
559 if (mentions_vars_p_common (t
))
561 CHECK_NO_VAR (DECL_NAME (t
));
562 CHECK_VAR (DECL_CONTEXT (t
));
566 /* Check presence of pointers to decls in fields of a decl_common T. */
569 mentions_vars_p_decl_common (tree t
)
571 if (mentions_vars_p_decl_minimal (t
))
573 CHECK_VAR (DECL_SIZE (t
));
574 CHECK_VAR (DECL_SIZE_UNIT (t
));
575 CHECK_VAR (DECL_INITIAL (t
));
576 CHECK_NO_VAR (DECL_ATTRIBUTES (t
));
577 CHECK_VAR (DECL_ABSTRACT_ORIGIN (t
));
581 /* Check presence of pointers to decls in fields of a decl_with_vis T. */
584 mentions_vars_p_decl_with_vis (tree t
)
586 if (mentions_vars_p_decl_common (t
))
589 /* Accessor macro has side-effects, use field-name here. */
590 CHECK_NO_VAR (t
->decl_with_vis
.assembler_name
);
594 /* Check presence of pointers to decls in fields of a decl_non_common T. */
597 mentions_vars_p_decl_non_common (tree t
)
599 if (mentions_vars_p_decl_with_vis (t
))
601 CHECK_NO_VAR (DECL_RESULT_FLD (t
));
605 /* Check presence of pointers to decls in fields of a decl_non_common T. */
608 mentions_vars_p_function (tree t
)
610 if (mentions_vars_p_decl_non_common (t
))
612 CHECK_NO_VAR (DECL_ARGUMENTS (t
));
613 CHECK_NO_VAR (DECL_VINDEX (t
));
614 CHECK_VAR (DECL_FUNCTION_PERSONALITY (t
));
618 /* Check presence of pointers to decls in fields of a field_decl T. */
621 mentions_vars_p_field_decl (tree t
)
623 if (mentions_vars_p_decl_common (t
))
625 CHECK_VAR (DECL_FIELD_OFFSET (t
));
626 CHECK_NO_VAR (DECL_BIT_FIELD_TYPE (t
));
627 CHECK_NO_VAR (DECL_QUALIFIER (t
));
628 CHECK_NO_VAR (DECL_FIELD_BIT_OFFSET (t
));
629 CHECK_NO_VAR (DECL_FCONTEXT (t
));
633 /* Check presence of pointers to decls in fields of a type T. */
636 mentions_vars_p_type (tree t
)
638 if (mentions_vars_p_common (t
))
640 CHECK_NO_VAR (TYPE_CACHED_VALUES (t
));
641 CHECK_VAR (TYPE_SIZE (t
));
642 CHECK_VAR (TYPE_SIZE_UNIT (t
));
643 CHECK_NO_VAR (TYPE_ATTRIBUTES (t
));
644 CHECK_NO_VAR (TYPE_NAME (t
));
646 CHECK_VAR (TYPE_MINVAL (t
));
647 CHECK_VAR (TYPE_MAXVAL (t
));
649 /* Accessor is for derived node types only. */
650 CHECK_NO_VAR (t
->type_non_common
.binfo
);
652 CHECK_VAR (TYPE_CONTEXT (t
));
653 CHECK_NO_VAR (TYPE_CANONICAL (t
));
654 CHECK_NO_VAR (TYPE_MAIN_VARIANT (t
));
655 CHECK_NO_VAR (TYPE_NEXT_VARIANT (t
));
659 /* Check presence of pointers to decls in fields of a BINFO T. */
662 mentions_vars_p_binfo (tree t
)
664 unsigned HOST_WIDE_INT i
, n
;
666 if (mentions_vars_p_common (t
))
668 CHECK_VAR (BINFO_VTABLE (t
));
669 CHECK_NO_VAR (BINFO_OFFSET (t
));
670 CHECK_NO_VAR (BINFO_VIRTUALS (t
));
671 CHECK_NO_VAR (BINFO_VPTR_FIELD (t
));
672 n
= vec_safe_length (BINFO_BASE_ACCESSES (t
));
673 for (i
= 0; i
< n
; i
++)
674 CHECK_NO_VAR (BINFO_BASE_ACCESS (t
, i
));
675 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
676 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
677 n
= BINFO_N_BASE_BINFOS (t
);
678 for (i
= 0; i
< n
; i
++)
679 CHECK_NO_VAR (BINFO_BASE_BINFO (t
, i
));
683 /* Check presence of pointers to decls in fields of a CONSTRUCTOR T. */
686 mentions_vars_p_constructor (tree t
)
688 unsigned HOST_WIDE_INT idx
;
691 if (mentions_vars_p_typed (t
))
694 for (idx
= 0; vec_safe_iterate (CONSTRUCTOR_ELTS (t
), idx
, &ce
); idx
++)
696 CHECK_NO_VAR (ce
->index
);
697 CHECK_VAR (ce
->value
);
702 /* Check presence of pointers to decls in fields of an expression tree T. */
705 mentions_vars_p_expr (tree t
)
708 if (mentions_vars_p_typed (t
))
710 for (i
= TREE_OPERAND_LENGTH (t
) - 1; i
>= 0; --i
)
711 CHECK_VAR (TREE_OPERAND (t
, i
));
715 /* Check presence of pointers to decls in fields of an OMP_CLAUSE T. */
718 mentions_vars_p_omp_clause (tree t
)
721 if (mentions_vars_p_common (t
))
723 for (i
= omp_clause_num_ops
[OMP_CLAUSE_CODE (t
)] - 1; i
>= 0; --i
)
724 CHECK_VAR (OMP_CLAUSE_OPERAND (t
, i
));
728 /* Check presence of pointers to decls that needs later fixup in T. */
731 mentions_vars_p (tree t
)
733 switch (TREE_CODE (t
))
735 case IDENTIFIER_NODE
:
739 CHECK_VAR (TREE_VALUE (t
));
740 CHECK_VAR (TREE_PURPOSE (t
));
741 CHECK_NO_VAR (TREE_CHAIN (t
));
745 return mentions_vars_p_field_decl (t
);
754 return mentions_vars_p_decl_common (t
);
757 return mentions_vars_p_decl_with_vis (t
);
760 return mentions_vars_p_decl_non_common (t
);
763 return mentions_vars_p_function (t
);
766 return mentions_vars_p_binfo (t
);
768 case PLACEHOLDER_EXPR
:
769 return mentions_vars_p_common (t
);
772 case TRANSLATION_UNIT_DECL
:
773 case OPTIMIZATION_NODE
:
774 case TARGET_OPTION_NODE
:
778 return mentions_vars_p_constructor (t
);
781 return mentions_vars_p_omp_clause (t
);
786 if (mentions_vars_p_type (t
))
791 if (mentions_vars_p_expr (t
))
794 else if (CONSTANT_CLASS_P (t
))
795 CHECK_NO_VAR (TREE_TYPE (t
));
803 /* Return the resolution for the decl with index INDEX from DATA_IN. */
805 static enum ld_plugin_symbol_resolution
806 get_resolution (struct data_in
*data_in
, unsigned index
)
808 if (data_in
->globals_resolution
.exists ())
810 ld_plugin_symbol_resolution_t ret
;
811 /* We can have references to not emitted functions in
812 DECL_FUNCTION_PERSONALITY at least. So we can and have
813 to indeed return LDPR_UNKNOWN in some cases. */
814 if (data_in
->globals_resolution
.length () <= index
)
816 ret
= data_in
->globals_resolution
[index
];
820 /* Delay resolution finding until decl merging. */
824 /* We need to record resolutions until symbol table is read. */
826 register_resolution (struct lto_file_decl_data
*file_data
, tree decl
,
827 enum ld_plugin_symbol_resolution resolution
)
829 if (resolution
== LDPR_UNKNOWN
)
831 if (!file_data
->resolution_map
)
832 file_data
->resolution_map
833 = new hash_map
<tree
, ld_plugin_symbol_resolution
>;
834 file_data
->resolution_map
->put (decl
, resolution
);
837 /* Register DECL with the global symbol table and change its
838 name if necessary to avoid name clashes for static globals across
842 lto_register_var_decl_in_symtab (struct data_in
*data_in
, tree decl
,
847 /* Variable has file scope, not local. */
848 if (!TREE_PUBLIC (decl
)
849 && !((context
= decl_function_context (decl
))
850 && auto_var_in_fn_p (decl
, context
)))
851 rest_of_decl_compilation (decl
, 1, 0);
853 /* If this variable has already been declared, queue the
854 declaration for merging. */
855 if (TREE_PUBLIC (decl
))
856 register_resolution (data_in
->file_data
,
857 decl
, get_resolution (data_in
, ix
));
861 /* Register DECL with the global symbol table and change its
862 name if necessary to avoid name clashes for static globals across
863 different files. DATA_IN contains descriptors and tables for the
867 lto_register_function_decl_in_symtab (struct data_in
*data_in
, tree decl
,
870 /* If this variable has already been declared, queue the
871 declaration for merging. */
872 if (TREE_PUBLIC (decl
) && !DECL_ABSTRACT_P (decl
))
873 register_resolution (data_in
->file_data
,
874 decl
, get_resolution (data_in
, ix
));
878 /* For the type T re-materialize it in the type variant list and
879 the pointer/reference-to chains. */
882 lto_fixup_prevailing_type (tree t
)
884 /* The following re-creates proper variant lists while fixing up
885 the variant leaders. We do not stream TYPE_NEXT_VARIANT so the
886 variant list state before fixup is broken. */
888 /* If we are not our own variant leader link us into our new leaders
890 if (TYPE_MAIN_VARIANT (t
) != t
)
892 tree mv
= TYPE_MAIN_VARIANT (t
);
893 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (mv
);
894 TYPE_NEXT_VARIANT (mv
) = t
;
897 /* The following reconstructs the pointer chains
898 of the new pointed-to type if we are a main variant. We do
899 not stream those so they are broken before fixup. */
900 if (TREE_CODE (t
) == POINTER_TYPE
901 && TYPE_MAIN_VARIANT (t
) == t
)
903 TYPE_NEXT_PTR_TO (t
) = TYPE_POINTER_TO (TREE_TYPE (t
));
904 TYPE_POINTER_TO (TREE_TYPE (t
)) = t
;
906 else if (TREE_CODE (t
) == REFERENCE_TYPE
907 && TYPE_MAIN_VARIANT (t
) == t
)
909 TYPE_NEXT_REF_TO (t
) = TYPE_REFERENCE_TO (TREE_TYPE (t
));
910 TYPE_REFERENCE_TO (TREE_TYPE (t
)) = t
;
915 /* We keep prevailing tree SCCs in a hashtable with manual collision
916 handling (in case all hashes compare the same) and keep the colliding
917 entries in the tree_scc->next chain. */
922 /* Hash of the whole SCC. */
924 /* Number of trees in the SCC. */
926 /* Number of possible entries into the SCC (tree nodes [0..entry_len-1]
927 which share the same individual tree hash). */
929 /* The members of the SCC.
930 We only need to remember the first entry node candidate for prevailing
931 SCCs (but of course have access to all entries for SCCs we are
933 ??? For prevailing SCCs we really only need hash and the first
934 entry candidate, but that's too awkward to implement. */
938 struct tree_scc_hasher
: nofree_ptr_hash
<tree_scc
>
940 static inline hashval_t
hash (const tree_scc
*);
941 static inline bool equal (const tree_scc
*, const tree_scc
*);
945 tree_scc_hasher::hash (const tree_scc
*scc
)
951 tree_scc_hasher::equal (const tree_scc
*scc1
, const tree_scc
*scc2
)
953 if (scc1
->hash
!= scc2
->hash
954 || scc1
->len
!= scc2
->len
955 || scc1
->entry_len
!= scc2
->entry_len
)
960 static hash_table
<tree_scc_hasher
> *tree_scc_hash
;
961 static struct obstack tree_scc_hash_obstack
;
963 static unsigned long num_merged_types
;
964 static unsigned long num_prevailing_types
;
965 static unsigned long num_type_scc_trees
;
966 static unsigned long total_scc_size
;
967 static unsigned long num_sccs_read
;
968 static unsigned long total_scc_size_merged
;
969 static unsigned long num_sccs_merged
;
970 static unsigned long num_scc_compares
;
971 static unsigned long num_scc_compare_collisions
;
974 /* Compare the two entries T1 and T2 of two SCCs that are possibly equal,
975 recursing through in-SCC tree edges. Returns true if the SCCs entered
976 through T1 and T2 are equal and fills in *MAP with the pairs of
977 SCC entries we visited, starting with (*MAP)[0] = T1 and (*MAP)[1] = T2. */
980 compare_tree_sccs_1 (tree t1
, tree t2
, tree
**map
)
984 /* Mark already visited nodes. */
985 TREE_ASM_WRITTEN (t2
) = 1;
987 /* Push the pair onto map. */
992 /* Compare value-fields. */
993 #define compare_values(X) \
995 if (X(t1) != X(t2)) \
999 compare_values (TREE_CODE
);
1000 code
= TREE_CODE (t1
);
1004 compare_values (TREE_SIDE_EFFECTS
);
1005 compare_values (TREE_CONSTANT
);
1006 compare_values (TREE_READONLY
);
1007 compare_values (TREE_PUBLIC
);
1009 compare_values (TREE_ADDRESSABLE
);
1010 compare_values (TREE_THIS_VOLATILE
);
1012 compare_values (DECL_UNSIGNED
);
1013 else if (TYPE_P (t1
))
1014 compare_values (TYPE_UNSIGNED
);
1016 compare_values (TYPE_ARTIFICIAL
);
1018 compare_values (TREE_NO_WARNING
);
1019 compare_values (TREE_NOTHROW
);
1020 compare_values (TREE_STATIC
);
1021 if (code
!= TREE_BINFO
)
1022 compare_values (TREE_PRIVATE
);
1023 compare_values (TREE_PROTECTED
);
1024 compare_values (TREE_DEPRECATED
);
1027 if (AGGREGATE_TYPE_P (t1
))
1028 compare_values (TYPE_REVERSE_STORAGE_ORDER
);
1030 compare_values (TYPE_SATURATING
);
1031 compare_values (TYPE_ADDR_SPACE
);
1033 else if (code
== SSA_NAME
)
1034 compare_values (SSA_NAME_IS_DEFAULT_DEF
);
1036 if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
1038 if (!wi::eq_p (t1
, t2
))
1042 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
1044 /* ??? No suitable compare routine available. */
1045 REAL_VALUE_TYPE r1
= TREE_REAL_CST (t1
);
1046 REAL_VALUE_TYPE r2
= TREE_REAL_CST (t2
);
1048 || r1
.decimal
!= r2
.decimal
1049 || r1
.sign
!= r2
.sign
1050 || r1
.signalling
!= r2
.signalling
1051 || r1
.canonical
!= r2
.canonical
1052 || r1
.uexp
!= r2
.uexp
)
1054 for (unsigned i
= 0; i
< SIGSZ
; ++i
)
1055 if (r1
.sig
[i
] != r2
.sig
[i
])
1059 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
1060 if (!fixed_compare (EQ_EXPR
,
1061 TREE_FIXED_CST_PTR (t1
), TREE_FIXED_CST_PTR (t2
)))
1065 /* We want to compare locations up to the point where it makes
1066 a difference for streaming - thus whether the decl is builtin or not. */
1067 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
1068 compare_values (streamer_handle_as_builtin_p
);
1070 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1072 compare_values (DECL_MODE
);
1073 compare_values (DECL_NONLOCAL
);
1074 compare_values (DECL_VIRTUAL_P
);
1075 compare_values (DECL_IGNORED_P
);
1076 compare_values (DECL_ABSTRACT_P
);
1077 compare_values (DECL_ARTIFICIAL
);
1078 compare_values (DECL_USER_ALIGN
);
1079 compare_values (DECL_PRESERVE_P
);
1080 compare_values (DECL_EXTERNAL
);
1081 compare_values (DECL_GIMPLE_REG_P
);
1082 compare_values (DECL_ALIGN
);
1083 if (code
== LABEL_DECL
)
1085 compare_values (EH_LANDING_PAD_NR
);
1086 compare_values (LABEL_DECL_UID
);
1088 else if (code
== FIELD_DECL
)
1090 compare_values (DECL_PACKED
);
1091 compare_values (DECL_NONADDRESSABLE_P
);
1092 compare_values (DECL_OFFSET_ALIGN
);
1094 else if (code
== VAR_DECL
)
1096 compare_values (DECL_HAS_DEBUG_EXPR_P
);
1097 compare_values (DECL_NONLOCAL_FRAME
);
1099 if (code
== RESULT_DECL
1100 || code
== PARM_DECL
1101 || code
== VAR_DECL
)
1103 compare_values (DECL_BY_REFERENCE
);
1104 if (code
== VAR_DECL
1105 || code
== PARM_DECL
)
1106 compare_values (DECL_HAS_VALUE_EXPR_P
);
1110 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
1111 compare_values (DECL_REGISTER
);
1113 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1115 compare_values (DECL_COMMON
);
1116 compare_values (DECL_DLLIMPORT_P
);
1117 compare_values (DECL_WEAK
);
1118 compare_values (DECL_SEEN_IN_BIND_EXPR_P
);
1119 compare_values (DECL_COMDAT
);
1120 compare_values (DECL_VISIBILITY
);
1121 compare_values (DECL_VISIBILITY_SPECIFIED
);
1122 if (code
== VAR_DECL
)
1124 compare_values (DECL_HARD_REGISTER
);
1125 /* DECL_IN_TEXT_SECTION is set during final asm output only. */
1126 compare_values (DECL_IN_CONSTANT_POOL
);
1130 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1132 compare_values (DECL_BUILT_IN_CLASS
);
1133 compare_values (DECL_STATIC_CONSTRUCTOR
);
1134 compare_values (DECL_STATIC_DESTRUCTOR
);
1135 compare_values (DECL_UNINLINABLE
);
1136 compare_values (DECL_POSSIBLY_INLINED
);
1137 compare_values (DECL_IS_NOVOPS
);
1138 compare_values (DECL_IS_RETURNS_TWICE
);
1139 compare_values (DECL_IS_MALLOC
);
1140 compare_values (DECL_IS_OPERATOR_NEW
);
1141 compare_values (DECL_DECLARED_INLINE_P
);
1142 compare_values (DECL_STATIC_CHAIN
);
1143 compare_values (DECL_NO_INLINE_WARNING_P
);
1144 compare_values (DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT
);
1145 compare_values (DECL_NO_LIMIT_STACK
);
1146 compare_values (DECL_DISREGARD_INLINE_LIMITS
);
1147 compare_values (DECL_PURE_P
);
1148 compare_values (DECL_LOOPING_CONST_OR_PURE_P
);
1149 compare_values (DECL_FINAL_P
);
1150 compare_values (DECL_CXX_CONSTRUCTOR_P
);
1151 compare_values (DECL_CXX_DESTRUCTOR_P
);
1152 if (DECL_BUILT_IN_CLASS (t1
) != NOT_BUILT_IN
)
1153 compare_values (DECL_FUNCTION_CODE
);
1156 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
1158 compare_values (TYPE_MODE
);
1159 compare_values (TYPE_STRING_FLAG
);
1160 compare_values (TYPE_NEEDS_CONSTRUCTING
);
1161 if (RECORD_OR_UNION_TYPE_P (t1
))
1163 compare_values (TYPE_TRANSPARENT_AGGR
);
1164 compare_values (TYPE_FINAL_P
);
1166 else if (code
== ARRAY_TYPE
)
1167 compare_values (TYPE_NONALIASED_COMPONENT
);
1168 compare_values (TYPE_PACKED
);
1169 compare_values (TYPE_RESTRICT
);
1170 compare_values (TYPE_USER_ALIGN
);
1171 compare_values (TYPE_READONLY
);
1172 compare_values (TYPE_PRECISION
);
1173 compare_values (TYPE_ALIGN
);
1174 /* Do not compare TYPE_ALIAS_SET. Doing so introduce ordering issues
1175 with calls to get_alias_set which may initialize it for streamed
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 compare_tree_edges (DECL_ABSTRACT_ORIGIN (t1
), DECL_ABSTRACT_ORIGIN (t2
));
1319 if ((code
== VAR_DECL
1320 || code
== PARM_DECL
)
1321 && DECL_HAS_VALUE_EXPR_P (t1
))
1322 compare_tree_edges (DECL_VALUE_EXPR (t1
), DECL_VALUE_EXPR (t2
));
1323 if (code
== VAR_DECL
1324 && DECL_HAS_DEBUG_EXPR_P (t1
))
1325 compare_tree_edges (DECL_DEBUG_EXPR (t1
), DECL_DEBUG_EXPR (t2
));
1326 /* LTO specific edges. */
1327 if (code
!= FUNCTION_DECL
1328 && code
!= TRANSLATION_UNIT_DECL
)
1329 compare_tree_edges (DECL_INITIAL (t1
), DECL_INITIAL (t2
));
1332 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
1334 if (code
== FUNCTION_DECL
)
1337 for (a1
= DECL_ARGUMENTS (t1
), a2
= DECL_ARGUMENTS (t2
);
1339 a1
= TREE_CHAIN (a1
), a2
= TREE_CHAIN (a2
))
1340 compare_tree_edges (a1
, a2
);
1341 compare_tree_edges (DECL_RESULT (t1
), DECL_RESULT (t2
));
1343 else if (code
== TYPE_DECL
)
1344 compare_tree_edges (DECL_ORIGINAL_TYPE (t1
), DECL_ORIGINAL_TYPE (t2
));
1347 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1349 /* Make sure we don't inadvertently set the assembler name. */
1350 if (DECL_ASSEMBLER_NAME_SET_P (t1
))
1351 compare_tree_edges (DECL_ASSEMBLER_NAME (t1
),
1352 DECL_ASSEMBLER_NAME (t2
));
1355 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
1357 compare_tree_edges (DECL_FIELD_OFFSET (t1
), DECL_FIELD_OFFSET (t2
));
1358 compare_tree_edges (DECL_BIT_FIELD_TYPE (t1
), DECL_BIT_FIELD_TYPE (t2
));
1359 compare_tree_edges (DECL_BIT_FIELD_REPRESENTATIVE (t1
),
1360 DECL_BIT_FIELD_REPRESENTATIVE (t2
));
1361 compare_tree_edges (DECL_FIELD_BIT_OFFSET (t1
),
1362 DECL_FIELD_BIT_OFFSET (t2
));
1363 compare_tree_edges (DECL_FCONTEXT (t1
), DECL_FCONTEXT (t2
));
1366 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1368 compare_tree_edges (DECL_FUNCTION_PERSONALITY (t1
),
1369 DECL_FUNCTION_PERSONALITY (t2
));
1370 compare_tree_edges (DECL_VINDEX (t1
), DECL_VINDEX (t2
));
1371 compare_tree_edges (DECL_FUNCTION_SPECIFIC_TARGET (t1
),
1372 DECL_FUNCTION_SPECIFIC_TARGET (t2
));
1373 compare_tree_edges (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t1
),
1374 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t2
));
1377 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
1379 compare_tree_edges (TYPE_SIZE (t1
), TYPE_SIZE (t2
));
1380 compare_tree_edges (TYPE_SIZE_UNIT (t1
), TYPE_SIZE_UNIT (t2
));
1381 compare_tree_edges (TYPE_ATTRIBUTES (t1
), TYPE_ATTRIBUTES (t2
));
1382 compare_tree_edges (TYPE_NAME (t1
), TYPE_NAME (t2
));
1383 /* Do not compare TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
1384 reconstructed during fixup. */
1385 /* Do not compare TYPE_NEXT_VARIANT, we reconstruct the variant lists
1387 compare_tree_edges (TYPE_MAIN_VARIANT (t1
), TYPE_MAIN_VARIANT (t2
));
1388 /* ??? Global types from different TUs have non-matching
1389 TRANSLATION_UNIT_DECLs. Still merge them if they are otherwise
1391 if (TYPE_FILE_SCOPE_P (t1
) && TYPE_FILE_SCOPE_P (t2
))
1394 compare_tree_edges (TYPE_CONTEXT (t1
), TYPE_CONTEXT (t2
));
1395 /* TYPE_CANONICAL is re-computed during type merging, so do not
1397 compare_tree_edges (TYPE_STUB_DECL (t1
), TYPE_STUB_DECL (t2
));
1400 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
1402 if (code
== ENUMERAL_TYPE
)
1403 compare_tree_edges (TYPE_VALUES (t1
), TYPE_VALUES (t2
));
1404 else if (code
== ARRAY_TYPE
)
1405 compare_tree_edges (TYPE_DOMAIN (t1
), TYPE_DOMAIN (t2
));
1406 else if (RECORD_OR_UNION_TYPE_P (t1
))
1409 for (f1
= TYPE_FIELDS (t1
), f2
= TYPE_FIELDS (t2
);
1411 f1
= TREE_CHAIN (f1
), f2
= TREE_CHAIN (f2
))
1412 compare_tree_edges (f1
, f2
);
1413 compare_tree_edges (TYPE_BINFO (t1
), TYPE_BINFO (t2
));
1415 else if (code
== FUNCTION_TYPE
1416 || code
== METHOD_TYPE
)
1417 compare_tree_edges (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
));
1418 if (!POINTER_TYPE_P (t1
))
1419 compare_tree_edges (TYPE_MINVAL (t1
), TYPE_MINVAL (t2
));
1420 compare_tree_edges (TYPE_MAXVAL (t1
), TYPE_MAXVAL (t2
));
1423 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
1425 compare_tree_edges (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
));
1426 compare_tree_edges (TREE_VALUE (t1
), TREE_VALUE (t2
));
1427 compare_tree_edges (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
1430 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1431 for (int i
= 0; i
< TREE_VEC_LENGTH (t1
); i
++)
1432 compare_tree_edges (TREE_VEC_ELT (t1
, i
), TREE_VEC_ELT (t2
, i
));
1434 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
1436 for (int i
= 0; i
< TREE_OPERAND_LENGTH (t1
); i
++)
1437 compare_tree_edges (TREE_OPERAND (t1
, i
),
1438 TREE_OPERAND (t2
, i
));
1440 /* BLOCKs are function local and we don't merge anything there. */
1441 if (TREE_BLOCK (t1
) || TREE_BLOCK (t2
))
1445 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1449 /* Lengths have already been compared above. */
1450 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (t1
), i
, t
)
1451 compare_tree_edges (t
, BINFO_BASE_BINFO (t2
, i
));
1452 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (t1
), i
, t
)
1453 compare_tree_edges (t
, BINFO_BASE_ACCESS (t2
, i
));
1454 compare_tree_edges (BINFO_OFFSET (t1
), BINFO_OFFSET (t2
));
1455 compare_tree_edges (BINFO_VTABLE (t1
), BINFO_VTABLE (t2
));
1456 compare_tree_edges (BINFO_VPTR_FIELD (t1
), BINFO_VPTR_FIELD (t2
));
1457 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
1458 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
1461 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1465 /* Lengths have already been compared above. */
1466 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, index
, value
)
1468 compare_tree_edges (index
, CONSTRUCTOR_ELT (t2
, i
)->index
);
1469 compare_tree_edges (value
, CONSTRUCTOR_ELT (t2
, i
)->value
);
1473 if (code
== OMP_CLAUSE
)
1477 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (t1
)]; i
++)
1478 compare_tree_edges (OMP_CLAUSE_OPERAND (t1
, i
),
1479 OMP_CLAUSE_OPERAND (t2
, i
));
1480 compare_tree_edges (OMP_CLAUSE_CHAIN (t1
), OMP_CLAUSE_CHAIN (t2
));
1483 #undef compare_tree_edges
1488 /* Compare the tree scc SCC to the prevailing candidate PSCC, filling
1489 out MAP if they are equal. */
1492 compare_tree_sccs (tree_scc
*pscc
, tree_scc
*scc
,
1495 /* Assume SCC entry hashes are sorted after their cardinality. Which
1496 means we can simply take the first n-tuple of equal hashes
1497 (which is recorded as entry_len) and do n SCC entry candidate
1499 for (unsigned i
= 0; i
< pscc
->entry_len
; ++i
)
1502 num_scc_compare_collisions
++;
1503 if (compare_tree_sccs_1 (pscc
->entries
[0], scc
->entries
[i
], &mapp
))
1505 /* Equal - no need to reset TREE_VISITED or TREE_ASM_WRITTEN
1506 on the scc as all trees will be freed. */
1509 /* Reset TREE_ASM_WRITTEN on scc for the next compare or in case
1510 the SCC prevails. */
1511 for (unsigned j
= 0; j
< scc
->len
; ++j
)
1512 TREE_ASM_WRITTEN (scc
->entries
[j
]) = 0;
1518 /* QSort sort function to sort a map of two pointers after the 2nd
1522 cmp_tree (const void *p1_
, const void *p2_
)
1524 tree
*p1
= (tree
*)(const_cast<void *>(p1_
));
1525 tree
*p2
= (tree
*)(const_cast<void *>(p2_
));
1528 return ((uintptr_t)p1
[1] < (uintptr_t)p2
[1]) ? -1 : 1;
1531 /* Try to unify the SCC with nodes FROM to FROM + LEN in CACHE and
1532 hash value SCC_HASH with an already recorded SCC. Return true if
1533 that was successful, otherwise return false. */
1536 unify_scc (struct data_in
*data_in
, unsigned from
,
1537 unsigned len
, unsigned scc_entry_len
, hashval_t scc_hash
)
1539 bool unified_p
= false;
1540 struct streamer_tree_cache_d
*cache
= data_in
->reader_cache
;
1542 = (tree_scc
*) alloca (sizeof (tree_scc
) + (len
- 1) * sizeof (tree
));
1544 scc
->hash
= scc_hash
;
1546 scc
->entry_len
= scc_entry_len
;
1547 for (unsigned i
= 0; i
< len
; ++i
)
1549 tree t
= streamer_tree_cache_get_tree (cache
, from
+ i
);
1550 scc
->entries
[i
] = t
;
1551 /* Do not merge SCCs with local entities inside them. Also do
1552 not merge TRANSLATION_UNIT_DECLs. */
1553 if (TREE_CODE (t
) == TRANSLATION_UNIT_DECL
1554 || (VAR_OR_FUNCTION_DECL_P (t
)
1555 && !(TREE_PUBLIC (t
) || DECL_EXTERNAL (t
)))
1556 || TREE_CODE (t
) == LABEL_DECL
)
1558 /* Avoid doing any work for these cases and do not worry to
1559 record the SCCs for further merging. */
1564 /* Look for the list of candidate SCCs to compare against. */
1566 slot
= tree_scc_hash
->find_slot_with_hash (scc
, scc_hash
, INSERT
);
1569 /* Try unifying against each candidate. */
1572 /* Set TREE_VISITED on the scc so we can easily identify tree nodes
1573 outside of the scc when following tree edges. Make sure
1574 that TREE_ASM_WRITTEN is unset so we can use it as 2nd bit
1575 to track whether we visited the SCC member during the compare.
1576 We cannot use TREE_VISITED on the pscc members as the extended
1577 scc and pscc can overlap. */
1578 for (unsigned i
= 0; i
< scc
->len
; ++i
)
1580 TREE_VISITED (scc
->entries
[i
]) = 1;
1581 gcc_checking_assert (!TREE_ASM_WRITTEN (scc
->entries
[i
]));
1584 tree
*map
= XALLOCAVEC (tree
, 2 * len
);
1585 for (tree_scc
*pscc
= *slot
; pscc
; pscc
= pscc
->next
)
1587 if (!compare_tree_sccs (pscc
, scc
, map
))
1590 /* Found an equal SCC. */
1592 num_scc_compare_collisions
--;
1594 total_scc_size_merged
+= len
;
1597 for (unsigned i
= 0; i
< len
; ++i
)
1599 tree t
= map
[2*i
+1];
1600 enum tree_code code
= TREE_CODE (t
);
1601 /* IDENTIFIER_NODEs should be singletons and are merged by the
1602 streamer. The others should be singletons, too, and we
1603 should not merge them in any way. */
1604 gcc_assert (code
!= TRANSLATION_UNIT_DECL
1605 && code
!= IDENTIFIER_NODE
1606 && !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 if (TYPE_P (scc
->entries
[i
]))
1634 free_node (scc
->entries
[i
]);
1640 /* Reset TREE_VISITED if we didn't unify the SCC with another. */
1642 for (unsigned i
= 0; i
< scc
->len
; ++i
)
1643 TREE_VISITED (scc
->entries
[i
]) = 0;
1646 /* If we didn't unify it to any candidate duplicate the relevant
1647 pieces to permanent storage and link it into the chain. */
1651 = XOBNEWVAR (&tree_scc_hash_obstack
, tree_scc
, sizeof (tree_scc
));
1652 memcpy (pscc
, scc
, sizeof (tree_scc
));
1653 pscc
->next
= (*slot
);
1660 /* Read all the symbols from buffer DATA, using descriptors in DECL_DATA.
1661 RESOLUTIONS is the set of symbols picked by the linker (read from the
1662 resolution file when the linker plugin is being used). */
1665 lto_read_decls (struct lto_file_decl_data
*decl_data
, const void *data
,
1666 vec
<ld_plugin_symbol_resolution_t
> resolutions
)
1668 const struct lto_decl_header
*header
= (const struct lto_decl_header
*) data
;
1669 const int decl_offset
= sizeof (struct lto_decl_header
);
1670 const int main_offset
= decl_offset
+ header
->decl_state_size
;
1671 const int string_offset
= main_offset
+ header
->main_size
;
1672 struct data_in
*data_in
;
1674 const uint32_t *data_ptr
, *data_end
;
1675 uint32_t num_decl_states
;
1677 lto_input_block
ib_main ((const char *) data
+ main_offset
,
1678 header
->main_size
, decl_data
->mode_table
);
1680 data_in
= lto_data_in_create (decl_data
, (const char *) data
+ string_offset
,
1681 header
->string_size
, resolutions
);
1683 /* We do not uniquify the pre-loaded cache entries, those are middle-end
1684 internal types that should not be merged. */
1686 /* Read the global declarations and types. */
1687 while (ib_main
.p
< ib_main
.len
)
1690 unsigned from
= data_in
->reader_cache
->nodes
.length ();
1691 /* Read and uniquify SCCs as in the input stream. */
1692 enum LTO_tags tag
= streamer_read_record_start (&ib_main
);
1693 if (tag
== LTO_tree_scc
)
1696 unsigned scc_entry_len
;
1697 hashval_t scc_hash
= lto_input_scc (&ib_main
, data_in
, &len_
,
1699 unsigned len
= data_in
->reader_cache
->nodes
.length () - from
;
1700 gcc_assert (len
== len_
);
1702 total_scc_size
+= len
;
1705 /* We have the special case of size-1 SCCs that are pre-merged
1706 by means of identifier and string sharing for example.
1707 ??? Maybe we should avoid streaming those as SCCs. */
1708 tree first
= streamer_tree_cache_get_tree (data_in
->reader_cache
,
1711 && (TREE_CODE (first
) == IDENTIFIER_NODE
1712 || TREE_CODE (first
) == INTEGER_CST
1713 || TREE_CODE (first
) == TRANSLATION_UNIT_DECL
1714 || streamer_handle_as_builtin_p (first
)))
1717 /* Try to unify the SCC with already existing ones. */
1719 && unify_scc (data_in
, from
,
1720 len
, scc_entry_len
, scc_hash
))
1723 /* Tree merging failed, mark entries in location cache as
1725 data_in
->location_cache
.accept_location_cache ();
1727 bool seen_type
= false;
1728 for (unsigned i
= 0; i
< len
; ++i
)
1730 tree t
= streamer_tree_cache_get_tree (data_in
->reader_cache
,
1732 /* Reconstruct the type variant and pointer-to/reference-to
1737 num_prevailing_types
++;
1738 lto_fixup_prevailing_type (t
);
1740 /* Compute the canonical type of all types.
1741 ??? Should be able to assert that !TYPE_CANONICAL. */
1742 if (TYPE_P (t
) && !TYPE_CANONICAL (t
))
1744 gimple_register_canonical_type (t
);
1746 register_odr_type (t
);
1748 /* Link shared INTEGER_CSTs into TYPE_CACHED_VALUEs of its
1749 type which is also member of this SCC. */
1750 if (TREE_CODE (t
) == INTEGER_CST
1751 && !TREE_OVERFLOW (t
))
1752 cache_integer_cst (t
);
1753 /* Register TYPE_DECLs with the debuginfo machinery. */
1755 && TREE_CODE (t
) == TYPE_DECL
)
1757 /* Dwarf2out needs location information.
1758 TODO: Moving this out of the streamer loop may noticealy
1759 improve ltrans linemap memory use. */
1760 data_in
->location_cache
.apply_location_cache ();
1761 debug_hooks
->type_decl (t
, !DECL_FILE_SCOPE_P (t
));
1765 /* Register variables and functions with the
1767 if (TREE_CODE (t
) == VAR_DECL
)
1768 lto_register_var_decl_in_symtab (data_in
, t
, from
+ i
);
1769 else if (TREE_CODE (t
) == FUNCTION_DECL
1770 && !DECL_BUILT_IN (t
))
1771 lto_register_function_decl_in_symtab (data_in
, t
, from
+ i
);
1772 /* Scan the tree for references to global functions or
1773 variables and record those for later fixup. */
1774 if (mentions_vars_p (t
))
1775 vec_safe_push (tree_with_vars
, t
);
1779 num_type_scc_trees
+= len
;
1783 /* Pickle stray references. */
1784 t
= lto_input_tree_1 (&ib_main
, data_in
, tag
, 0);
1785 gcc_assert (t
&& data_in
->reader_cache
->nodes
.length () == from
);
1788 data_in
->location_cache
.apply_location_cache ();
1790 /* Read in lto_in_decl_state objects. */
1791 data_ptr
= (const uint32_t *) ((const char*) data
+ decl_offset
);
1793 (const uint32_t *) ((const char*) data_ptr
+ header
->decl_state_size
);
1794 num_decl_states
= *data_ptr
++;
1796 gcc_assert (num_decl_states
> 0);
1797 decl_data
->global_decl_state
= lto_new_in_decl_state ();
1798 data_ptr
= lto_read_in_decl_state (data_in
, data_ptr
,
1799 decl_data
->global_decl_state
);
1801 /* Read in per-function decl states and enter them in hash table. */
1802 decl_data
->function_decl_states
=
1803 hash_table
<decl_state_hasher
>::create_ggc (37);
1805 for (i
= 1; i
< num_decl_states
; i
++)
1807 struct lto_in_decl_state
*state
= lto_new_in_decl_state ();
1809 data_ptr
= lto_read_in_decl_state (data_in
, data_ptr
, state
);
1810 lto_in_decl_state
**slot
1811 = decl_data
->function_decl_states
->find_slot (state
, INSERT
);
1812 gcc_assert (*slot
== NULL
);
1816 if (data_ptr
!= data_end
)
1817 internal_error ("bytecode stream: garbage at the end of symbols section");
1819 /* Set the current decl state to be the global state. */
1820 decl_data
->current_decl_state
= decl_data
->global_decl_state
;
1822 lto_data_in_delete (data_in
);
1825 /* Custom version of strtoll, which is not portable. */
1828 lto_parse_hex (const char *p
)
1832 for (; *p
!= '\0'; ++p
)
1837 if (c
>= '0' && c
<= '9')
1839 else if (c
>= 'a' && c
<= 'f')
1840 part
= c
- 'a' + 10;
1841 else if (c
>= 'A' && c
<= 'F')
1842 part
= c
- 'A' + 10;
1844 internal_error ("could not parse hex number");
1851 /* Read resolution for file named FILE_NAME. The resolution is read from
1855 lto_resolution_read (splay_tree file_ids
, FILE *resolution
, lto_file
*file
)
1857 /* We require that objects in the resolution file are in the same
1858 order as the lto1 command line. */
1859 unsigned int name_len
;
1861 unsigned int num_symbols
;
1863 struct lto_file_decl_data
*file_data
;
1864 splay_tree_node nd
= NULL
;
1869 name_len
= strlen (file
->filename
);
1870 obj_name
= XNEWVEC (char, name_len
+ 1);
1871 fscanf (resolution
, " "); /* Read white space. */
1873 fread (obj_name
, sizeof (char), name_len
, resolution
);
1874 obj_name
[name_len
] = '\0';
1875 if (filename_cmp (obj_name
, file
->filename
) != 0)
1876 internal_error ("unexpected file name %s in linker resolution file. "
1877 "Expected %s", obj_name
, file
->filename
);
1878 if (file
->offset
!= 0)
1883 t
= fscanf (resolution
, "@0x%16s", offset_p
);
1885 internal_error ("could not parse file offset");
1886 offset
= lto_parse_hex (offset_p
);
1887 if (offset
!= file
->offset
)
1888 internal_error ("unexpected offset");
1893 fscanf (resolution
, "%u", &num_symbols
);
1895 for (i
= 0; i
< num_symbols
; i
++)
1899 unsigned HOST_WIDE_INT id
;
1901 enum ld_plugin_symbol_resolution r
= (enum ld_plugin_symbol_resolution
) 0;
1903 unsigned int lto_resolution_str_len
=
1904 sizeof (lto_resolution_str
) / sizeof (char *);
1907 t
= fscanf (resolution
, "%u " HOST_WIDE_INT_PRINT_HEX_PURE
" %26s %*[^\n]\n",
1908 &index
, &id
, r_str
);
1910 internal_error ("invalid line in the resolution file");
1912 for (j
= 0; j
< lto_resolution_str_len
; j
++)
1914 if (strcmp (lto_resolution_str
[j
], r_str
) == 0)
1916 r
= (enum ld_plugin_symbol_resolution
) j
;
1920 if (j
== lto_resolution_str_len
)
1921 internal_error ("invalid resolution in the resolution file");
1923 if (!(nd
&& lto_splay_tree_id_equal_p (nd
->key
, id
)))
1925 nd
= lto_splay_tree_lookup (file_ids
, id
);
1927 internal_error ("resolution sub id %wx not in object file", id
);
1930 file_data
= (struct lto_file_decl_data
*)nd
->value
;
1931 /* The indexes are very sparse. To save memory save them in a compact
1932 format that is only unpacked later when the subfile is processed. */
1935 file_data
->respairs
.safe_push (rp
);
1936 if (file_data
->max_index
< index
)
1937 file_data
->max_index
= index
;
1941 /* List of file_decl_datas */
1942 struct file_data_list
1944 struct lto_file_decl_data
*first
, *last
;
1947 /* Is the name for a id'ed LTO section? */
1950 lto_section_with_id (const char *name
, unsigned HOST_WIDE_INT
*id
)
1954 if (strncmp (name
, section_name_prefix
, strlen (section_name_prefix
)))
1956 s
= strrchr (name
, '.');
1957 return s
&& sscanf (s
, "." HOST_WIDE_INT_PRINT_HEX_PURE
, id
) == 1;
1960 /* Create file_data of each sub file id */
1963 create_subid_section_table (struct lto_section_slot
*ls
, splay_tree file_ids
,
1964 struct file_data_list
*list
)
1966 struct lto_section_slot s_slot
, *new_slot
;
1967 unsigned HOST_WIDE_INT id
;
1971 struct lto_file_decl_data
*file_data
;
1973 if (!lto_section_with_id (ls
->name
, &id
))
1976 /* Find hash table of sub module id */
1977 nd
= lto_splay_tree_lookup (file_ids
, id
);
1980 file_data
= (struct lto_file_decl_data
*)nd
->value
;
1984 file_data
= ggc_alloc
<lto_file_decl_data
> ();
1985 memset(file_data
, 0, sizeof (struct lto_file_decl_data
));
1987 file_data
->section_hash_table
= lto_obj_create_section_hash_table ();;
1988 lto_splay_tree_insert (file_ids
, id
, file_data
);
1990 /* Maintain list in linker order */
1992 list
->first
= file_data
;
1994 list
->last
->next
= file_data
;
1995 list
->last
= file_data
;
1998 /* Copy section into sub module hash table */
1999 new_name
= XDUPVEC (char, ls
->name
, strlen (ls
->name
) + 1);
2000 s_slot
.name
= new_name
;
2001 hash_slot
= htab_find_slot (file_data
->section_hash_table
, &s_slot
, INSERT
);
2002 gcc_assert (*hash_slot
== NULL
);
2004 new_slot
= XDUP (struct lto_section_slot
, ls
);
2005 new_slot
->name
= new_name
;
2006 *hash_slot
= new_slot
;
2010 /* Read declarations and other initializations for a FILE_DATA. */
2013 lto_file_finalize (struct lto_file_decl_data
*file_data
, lto_file
*file
)
2017 vec
<ld_plugin_symbol_resolution_t
>
2018 resolutions
= vNULL
;
2022 /* Create vector for fast access of resolution. We do this lazily
2024 resolutions
.safe_grow_cleared (file_data
->max_index
+ 1);
2025 for (i
= 0; file_data
->respairs
.iterate (i
, &rp
); i
++)
2026 resolutions
[rp
->index
] = rp
->res
;
2027 file_data
->respairs
.release ();
2029 file_data
->renaming_hash_table
= lto_create_renaming_table ();
2030 file_data
->file_name
= file
->filename
;
2031 #ifdef ACCEL_COMPILER
2032 lto_input_mode_table (file_data
);
2034 file_data
->mode_table
= lto_mode_identity_table
;
2036 data
= lto_get_section_data (file_data
, LTO_section_decls
, NULL
, &len
);
2039 internal_error ("cannot read LTO decls from %s", file_data
->file_name
);
2042 /* Frees resolutions */
2043 lto_read_decls (file_data
, data
, resolutions
);
2044 lto_free_section_data (file_data
, LTO_section_decls
, NULL
, data
, len
);
2047 /* Finalize FILE_DATA in FILE and increase COUNT. */
2050 lto_create_files_from_ids (lto_file
*file
, struct lto_file_decl_data
*file_data
,
2053 lto_file_finalize (file_data
, file
);
2054 if (symtab
->dump_file
)
2055 fprintf (symtab
->dump_file
,
2056 "Creating file %s with sub id " HOST_WIDE_INT_PRINT_HEX
"\n",
2057 file_data
->file_name
, file_data
->id
);
2062 /* Generate a TREE representation for all types and external decls
2065 Read all of the globals out of the file. Then read the cgraph
2066 and process the .o index into the cgraph nodes so that it can open
2067 the .o file to load the functions and ipa information. */
2069 static struct lto_file_decl_data
*
2070 lto_file_read (lto_file
*file
, FILE *resolution_file
, int *count
)
2072 struct lto_file_decl_data
*file_data
= NULL
;
2073 splay_tree file_ids
;
2074 htab_t section_hash_table
;
2075 struct lto_section_slot
*section
;
2076 struct file_data_list file_list
;
2077 struct lto_section_list section_list
;
2079 memset (§ion_list
, 0, sizeof (struct lto_section_list
));
2080 section_hash_table
= lto_obj_build_section_table (file
, §ion_list
);
2082 /* Find all sub modules in the object and put their sections into new hash
2083 tables in a splay tree. */
2084 file_ids
= lto_splay_tree_new ();
2085 memset (&file_list
, 0, sizeof (struct file_data_list
));
2086 for (section
= section_list
.first
; section
!= NULL
; section
= section
->next
)
2087 create_subid_section_table (section
, file_ids
, &file_list
);
2089 /* Add resolutions to file ids */
2090 lto_resolution_read (file_ids
, resolution_file
, file
);
2092 /* Finalize each lto file for each submodule in the merged object */
2093 for (file_data
= file_list
.first
; file_data
!= NULL
; file_data
= file_data
->next
)
2094 lto_create_files_from_ids (file
, file_data
, count
);
2096 splay_tree_delete (file_ids
);
2097 htab_delete (section_hash_table
);
2099 return file_list
.first
;
2102 #if HAVE_MMAP_FILE && HAVE_SYSCONF && defined _SC_PAGE_SIZE
2103 #define LTO_MMAP_IO 1
2107 /* Page size of machine is used for mmap and munmap calls. */
2108 static size_t page_mask
;
2111 /* Get the section data of length LEN from FILENAME starting at
2112 OFFSET. The data segment must be freed by the caller when the
2113 caller is finished. Returns NULL if all was not well. */
2116 lto_read_section_data (struct lto_file_decl_data
*file_data
,
2117 intptr_t offset
, size_t len
)
2121 static char *fd_name
;
2123 intptr_t computed_len
;
2124 intptr_t computed_offset
;
2128 /* Keep a single-entry file-descriptor cache. The last file we
2129 touched will get closed at exit.
2130 ??? Eventually we want to add a more sophisticated larger cache
2131 or rather fix function body streaming to not stream them in
2132 practically random order. */
2134 && filename_cmp (fd_name
, file_data
->file_name
) != 0)
2142 fd
= open (file_data
->file_name
, O_RDONLY
|O_BINARY
);
2145 fatal_error (input_location
, "Cannot open %s", file_data
->file_name
);
2148 fd_name
= xstrdup (file_data
->file_name
);
2154 size_t page_size
= sysconf (_SC_PAGE_SIZE
);
2155 page_mask
= ~(page_size
- 1);
2158 computed_offset
= offset
& page_mask
;
2159 diff
= offset
- computed_offset
;
2160 computed_len
= len
+ diff
;
2162 result
= (char *) mmap (NULL
, computed_len
, PROT_READ
, MAP_PRIVATE
,
2163 fd
, computed_offset
);
2164 if (result
== MAP_FAILED
)
2166 fatal_error (input_location
, "Cannot map %s", file_data
->file_name
);
2170 return result
+ diff
;
2172 result
= (char *) xmalloc (len
);
2173 if (lseek (fd
, offset
, SEEK_SET
) != offset
2174 || read (fd
, result
, len
) != (ssize_t
) len
)
2177 fatal_error (input_location
, "Cannot read %s", file_data
->file_name
);
2181 /* Native windows doesn't supports delayed unlink on opened file. So
2182 we close file here again. This produces higher I/O load, but at least
2183 it prevents to have dangling file handles preventing unlink. */
2194 /* Get the section data from FILE_DATA of SECTION_TYPE with NAME.
2195 NAME will be NULL unless the section type is for a function
2199 get_section_data (struct lto_file_decl_data
*file_data
,
2200 enum lto_section_type section_type
,
2204 htab_t section_hash_table
= file_data
->section_hash_table
;
2205 struct lto_section_slot
*f_slot
;
2206 struct lto_section_slot s_slot
;
2207 const char *section_name
= lto_get_section_name (section_type
, name
, file_data
);
2211 s_slot
.name
= section_name
;
2212 f_slot
= (struct lto_section_slot
*) htab_find (section_hash_table
, &s_slot
);
2215 data
= lto_read_section_data (file_data
, f_slot
->start
, f_slot
->len
);
2219 free (CONST_CAST (char *, section_name
));
2224 /* Free the section data from FILE_DATA of SECTION_TYPE with NAME that
2225 starts at OFFSET and has LEN bytes. */
2228 free_section_data (struct lto_file_decl_data
*file_data ATTRIBUTE_UNUSED
,
2229 enum lto_section_type section_type ATTRIBUTE_UNUSED
,
2230 const char *name ATTRIBUTE_UNUSED
,
2231 const char *offset
, size_t len ATTRIBUTE_UNUSED
)
2234 intptr_t computed_len
;
2235 intptr_t computed_offset
;
2240 computed_offset
= ((intptr_t) offset
) & page_mask
;
2241 diff
= (intptr_t) offset
- computed_offset
;
2242 computed_len
= len
+ diff
;
2244 munmap ((caddr_t
) computed_offset
, computed_len
);
2246 free (CONST_CAST(char *, offset
));
2250 static lto_file
*current_lto_file
;
2252 /* Helper for qsort; compare partitions and return one with smaller size.
2253 We sort from greatest to smallest so parallel build doesn't stale on the
2254 longest compilation being executed too late. */
2257 cmp_partitions_size (const void *a
, const void *b
)
2259 const struct ltrans_partition_def
*pa
2260 = *(struct ltrans_partition_def
*const *)a
;
2261 const struct ltrans_partition_def
*pb
2262 = *(struct ltrans_partition_def
*const *)b
;
2263 return pb
->insns
- pa
->insns
;
2266 /* Helper for qsort; compare partitions and return one with smaller order. */
2269 cmp_partitions_order (const void *a
, const void *b
)
2271 const struct ltrans_partition_def
*pa
2272 = *(struct ltrans_partition_def
*const *)a
;
2273 const struct ltrans_partition_def
*pb
2274 = *(struct ltrans_partition_def
*const *)b
;
2275 int ordera
= -1, orderb
= -1;
2277 if (lto_symtab_encoder_size (pa
->encoder
))
2278 ordera
= lto_symtab_encoder_deref (pa
->encoder
, 0)->order
;
2279 if (lto_symtab_encoder_size (pb
->encoder
))
2280 orderb
= lto_symtab_encoder_deref (pb
->encoder
, 0)->order
;
2281 return orderb
- ordera
;
2284 /* Actually stream out ENCODER into TEMP_FILENAME. */
2287 do_stream_out (char *temp_filename
, lto_symtab_encoder_t encoder
)
2289 lto_file
*file
= lto_obj_file_open (temp_filename
, true);
2291 fatal_error (input_location
, "lto_obj_file_open() failed");
2292 lto_set_current_out_file (file
);
2294 ipa_write_optimization_summaries (encoder
);
2296 lto_set_current_out_file (NULL
);
2297 lto_obj_file_close (file
);
2301 /* Wait for forked process and signal errors. */
2302 #ifdef HAVE_WORKING_FORK
2310 #define WCONTINUED 0
2312 int w
= waitpid (0, &status
, WUNTRACED
| WCONTINUED
);
2314 fatal_error (input_location
, "waitpid failed");
2316 if (WIFEXITED (status
) && WEXITSTATUS (status
))
2317 fatal_error (input_location
, "streaming subprocess failed");
2318 else if (WIFSIGNALED (status
))
2319 fatal_error (input_location
,
2320 "streaming subprocess was killed by signal");
2322 while (!WIFEXITED (status
) && !WIFSIGNALED (status
));
2326 /* Stream out ENCODER into TEMP_FILENAME
2327 Fork if that seems to help. */
2330 stream_out (char *temp_filename
, lto_symtab_encoder_t encoder
,
2331 bool ARG_UNUSED (last
))
2333 #ifdef HAVE_WORKING_FORK
2336 if (lto_parallelism
<= 1)
2338 do_stream_out (temp_filename
, encoder
);
2342 /* Do not run more than LTO_PARALLELISM streamings
2343 FIXME: we ignore limits on jobserver. */
2344 if (lto_parallelism
> 0 && nruns
>= lto_parallelism
)
2349 /* If this is not the last parallel partition, execute new
2350 streaming process. */
2353 pid_t cpid
= fork ();
2357 setproctitle ("lto1-wpa-streaming");
2358 do_stream_out (temp_filename
, encoder
);
2361 /* Fork failed; lets do the job ourseleves. */
2362 else if (cpid
== -1)
2363 do_stream_out (temp_filename
, encoder
);
2367 /* Last partition; stream it and wait for all children to die. */
2371 do_stream_out (temp_filename
, encoder
);
2372 for (i
= 0; i
< nruns
; i
++)
2375 asm_nodes_output
= true;
2377 do_stream_out (temp_filename
, encoder
);
2381 /* Write all output files in WPA mode and the file with the list of
2385 lto_wpa_write_files (void)
2388 ltrans_partition part
;
2389 FILE *ltrans_output_list_stream
;
2390 char *temp_filename
;
2391 vec
<char *>temp_filenames
= vNULL
;
2394 /* Open the LTRANS output list. */
2395 if (!ltrans_output_list
)
2396 fatal_error (input_location
, "no LTRANS output list filename provided");
2398 timevar_push (TV_WHOPR_WPA
);
2400 FOR_EACH_VEC_ELT (ltrans_partitions
, i
, part
)
2401 lto_stats
.num_output_symtab_nodes
+= lto_symtab_encoder_size (part
->encoder
);
2403 timevar_pop (TV_WHOPR_WPA
);
2405 timevar_push (TV_WHOPR_WPA_IO
);
2407 /* Generate a prefix for the LTRANS unit files. */
2408 blen
= strlen (ltrans_output_list
);
2409 temp_filename
= (char *) xmalloc (blen
+ sizeof ("2147483648.o"));
2410 strcpy (temp_filename
, ltrans_output_list
);
2411 if (blen
> sizeof (".out")
2412 && strcmp (temp_filename
+ blen
- sizeof (".out") + 1,
2414 temp_filename
[blen
- sizeof (".out") + 1] = '\0';
2415 blen
= strlen (temp_filename
);
2417 n_sets
= ltrans_partitions
.length ();
2419 /* Sort partitions by size so small ones are compiled last.
2420 FIXME: Even when not reordering we may want to output one list for parallel make
2421 and other for final link command. */
2423 if (!flag_profile_reorder_functions
|| !flag_profile_use
)
2424 ltrans_partitions
.qsort (flag_toplevel_reorder
2425 ? cmp_partitions_size
2426 : cmp_partitions_order
);
2428 for (i
= 0; i
< n_sets
; i
++)
2430 ltrans_partition part
= ltrans_partitions
[i
];
2432 /* Write all the nodes in SET. */
2433 sprintf (temp_filename
+ blen
, "%u.o", i
);
2436 fprintf (stderr
, " %s (%s %i insns)", temp_filename
, part
->name
, part
->insns
);
2437 if (symtab
->dump_file
)
2439 lto_symtab_encoder_iterator lsei
;
2441 fprintf (symtab
->dump_file
, "Writing partition %s to file %s, %i insns\n",
2442 part
->name
, temp_filename
, part
->insns
);
2443 fprintf (symtab
->dump_file
, " Symbols in partition: ");
2444 for (lsei
= lsei_start_in_partition (part
->encoder
); !lsei_end_p (lsei
);
2445 lsei_next_in_partition (&lsei
))
2447 symtab_node
*node
= lsei_node (lsei
);
2448 fprintf (symtab
->dump_file
, "%s ", node
->asm_name ());
2450 fprintf (symtab
->dump_file
, "\n Symbols in boundary: ");
2451 for (lsei
= lsei_start (part
->encoder
); !lsei_end_p (lsei
);
2454 symtab_node
*node
= lsei_node (lsei
);
2455 if (!lto_symtab_encoder_in_partition_p (part
->encoder
, node
))
2457 fprintf (symtab
->dump_file
, "%s ", node
->asm_name ());
2458 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
);
2460 && lto_symtab_encoder_encode_body_p (part
->encoder
, cnode
))
2461 fprintf (symtab
->dump_file
, "(body included)");
2464 varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
);
2466 && lto_symtab_encoder_encode_initializer_p (part
->encoder
, vnode
))
2467 fprintf (symtab
->dump_file
, "(initializer included)");
2471 fprintf (symtab
->dump_file
, "\n");
2473 gcc_checking_assert (lto_symtab_encoder_size (part
->encoder
) || !i
);
2475 stream_out (temp_filename
, part
->encoder
, i
== n_sets
- 1);
2477 part
->encoder
= NULL
;
2479 temp_filenames
.safe_push (xstrdup (temp_filename
));
2481 ltrans_output_list_stream
= fopen (ltrans_output_list
, "w");
2482 if (ltrans_output_list_stream
== NULL
)
2483 fatal_error (input_location
,
2484 "opening LTRANS output list %s: %m", ltrans_output_list
);
2485 for (i
= 0; i
< n_sets
; i
++)
2487 unsigned int len
= strlen (temp_filenames
[i
]);
2488 if (fwrite (temp_filenames
[i
], 1, len
, ltrans_output_list_stream
) < len
2489 || fwrite ("\n", 1, 1, ltrans_output_list_stream
) < 1)
2490 fatal_error (input_location
, "writing to LTRANS output list %s: %m",
2491 ltrans_output_list
);
2492 free (temp_filenames
[i
]);
2494 temp_filenames
.release();
2496 lto_stats
.num_output_files
+= n_sets
;
2498 /* Close the LTRANS output list. */
2499 if (fclose (ltrans_output_list_stream
))
2500 fatal_error (input_location
,
2501 "closing LTRANS output list %s: %m", ltrans_output_list
);
2503 free_ltrans_partitions();
2504 free (temp_filename
);
2506 timevar_pop (TV_WHOPR_WPA_IO
);
2510 /* If TT is a variable or function decl replace it with its
2511 prevailing variant. */
2512 #define LTO_SET_PREVAIL(tt) \
2514 if ((tt) && VAR_OR_FUNCTION_DECL_P (tt) \
2515 && (TREE_PUBLIC (tt) || DECL_EXTERNAL (tt))) \
2517 tt = lto_symtab_prevailing_decl (tt); \
2522 /* Ensure that TT isn't a replacable var of function decl. */
2523 #define LTO_NO_PREVAIL(tt) \
2524 gcc_checking_assert (!(tt) || !VAR_OR_FUNCTION_DECL_P (tt))
2526 /* Given a tree T replace all fields referring to variables or functions
2527 with their prevailing variant. */
2529 lto_fixup_prevailing_decls (tree t
)
2531 enum tree_code code
= TREE_CODE (t
);
2534 gcc_checking_assert (code
!= TREE_BINFO
);
2535 LTO_NO_PREVAIL (TREE_TYPE (t
));
2536 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
)
2537 /* lto_symtab_prevail_decl use TREE_CHAIN to link to the prevailing decl.
2538 in the case T is a prevailed declaration we would ICE here. */
2539 && !VAR_OR_FUNCTION_DECL_P (t
))
2540 LTO_NO_PREVAIL (TREE_CHAIN (t
));
2543 LTO_NO_PREVAIL (DECL_NAME (t
));
2544 LTO_SET_PREVAIL (DECL_CONTEXT (t
));
2545 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
2547 LTO_SET_PREVAIL (DECL_SIZE (t
));
2548 LTO_SET_PREVAIL (DECL_SIZE_UNIT (t
));
2549 LTO_SET_PREVAIL (DECL_INITIAL (t
));
2550 LTO_NO_PREVAIL (DECL_ATTRIBUTES (t
));
2551 LTO_SET_PREVAIL (DECL_ABSTRACT_ORIGIN (t
));
2553 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
2555 LTO_NO_PREVAIL (t
->decl_with_vis
.assembler_name
);
2557 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
2559 LTO_NO_PREVAIL (DECL_RESULT_FLD (t
));
2561 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
2563 LTO_NO_PREVAIL (DECL_ARGUMENTS (t
));
2564 LTO_SET_PREVAIL (DECL_FUNCTION_PERSONALITY (t
));
2565 LTO_NO_PREVAIL (DECL_VINDEX (t
));
2567 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
2569 LTO_SET_PREVAIL (DECL_FIELD_OFFSET (t
));
2570 LTO_NO_PREVAIL (DECL_BIT_FIELD_TYPE (t
));
2571 LTO_NO_PREVAIL (DECL_QUALIFIER (t
));
2572 LTO_NO_PREVAIL (DECL_FIELD_BIT_OFFSET (t
));
2573 LTO_NO_PREVAIL (DECL_FCONTEXT (t
));
2576 else if (TYPE_P (t
))
2578 LTO_NO_PREVAIL (TYPE_CACHED_VALUES (t
));
2579 LTO_SET_PREVAIL (TYPE_SIZE (t
));
2580 LTO_SET_PREVAIL (TYPE_SIZE_UNIT (t
));
2581 LTO_NO_PREVAIL (TYPE_ATTRIBUTES (t
));
2582 LTO_NO_PREVAIL (TYPE_NAME (t
));
2584 LTO_SET_PREVAIL (TYPE_MINVAL (t
));
2585 LTO_SET_PREVAIL (TYPE_MAXVAL (t
));
2586 LTO_NO_PREVAIL (t
->type_non_common
.binfo
);
2588 LTO_SET_PREVAIL (TYPE_CONTEXT (t
));
2590 LTO_NO_PREVAIL (TYPE_CANONICAL (t
));
2591 LTO_NO_PREVAIL (TYPE_MAIN_VARIANT (t
));
2592 LTO_NO_PREVAIL (TYPE_NEXT_VARIANT (t
));
2594 else if (EXPR_P (t
))
2597 for (i
= TREE_OPERAND_LENGTH (t
) - 1; i
>= 0; --i
)
2598 LTO_SET_PREVAIL (TREE_OPERAND (t
, i
));
2600 else if (TREE_CODE (t
) == CONSTRUCTOR
)
2604 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), i
, val
)
2605 LTO_SET_PREVAIL (val
);
2612 LTO_SET_PREVAIL (TREE_VALUE (t
));
2613 LTO_SET_PREVAIL (TREE_PURPOSE (t
));
2614 LTO_NO_PREVAIL (TREE_PURPOSE (t
));
2620 /* If we fixed nothing, then we missed something seen by
2622 gcc_checking_assert (fixed
);
2624 #undef LTO_SET_PREVAIL
2625 #undef LTO_NO_PREVAIL
2627 /* Helper function of lto_fixup_decls. Walks the var and fn streams in STATE,
2628 replaces var and function decls with the corresponding prevailing def. */
2631 lto_fixup_state (struct lto_in_decl_state
*state
)
2635 /* Although we only want to replace FUNCTION_DECLs and VAR_DECLs,
2636 we still need to walk from all DECLs to find the reachable
2637 FUNCTION_DECLs and VAR_DECLs. */
2638 for (si
= 0; si
< LTO_N_DECL_STREAMS
; si
++)
2640 vec
<tree
, va_gc
> *trees
= state
->streams
[si
];
2641 for (i
= 0; i
< vec_safe_length (trees
); i
++)
2643 tree t
= (*trees
)[i
];
2644 if (flag_checking
&& TYPE_P (t
))
2646 if (VAR_OR_FUNCTION_DECL_P (t
)
2647 && (TREE_PUBLIC (t
) || DECL_EXTERNAL (t
)))
2648 (*trees
)[i
] = lto_symtab_prevailing_decl (t
);
2653 /* Fix the decls from all FILES. Replaces each decl with the corresponding
2657 lto_fixup_decls (struct lto_file_decl_data
**files
)
2663 FOR_EACH_VEC_ELT ((*tree_with_vars
), i
, t
)
2664 lto_fixup_prevailing_decls (t
);
2666 for (i
= 0; files
[i
]; i
++)
2668 struct lto_file_decl_data
*file
= files
[i
];
2669 struct lto_in_decl_state
*state
= file
->global_decl_state
;
2670 lto_fixup_state (state
);
2672 hash_table
<decl_state_hasher
>::iterator iter
;
2673 lto_in_decl_state
*elt
;
2674 FOR_EACH_HASH_TABLE_ELEMENT (*file
->function_decl_states
, elt
,
2675 lto_in_decl_state
*, iter
)
2676 lto_fixup_state (elt
);
2680 static GTY((length ("lto_stats.num_input_files + 1"))) struct lto_file_decl_data
**all_file_decl_data
;
2682 /* Turn file datas for sub files into a single array, so that they look
2683 like separate files for further passes. */
2686 lto_flatten_files (struct lto_file_decl_data
**orig
, int count
, int last_file_ix
)
2688 struct lto_file_decl_data
*n
, *next
;
2691 lto_stats
.num_input_files
= count
;
2693 = ggc_cleared_vec_alloc
<lto_file_decl_data_ptr
> (count
+ 1);
2694 /* Set the hooks so that all of the ipa passes can read in their data. */
2695 lto_set_in_hooks (all_file_decl_data
, get_section_data
, free_section_data
);
2696 for (i
= 0, k
= 0; i
< last_file_ix
; i
++)
2698 for (n
= orig
[i
]; n
!= NULL
; n
= next
)
2700 all_file_decl_data
[k
++] = n
;
2705 all_file_decl_data
[k
] = NULL
;
2706 gcc_assert (k
== count
);
2709 /* Input file data before flattening (i.e. splitting them to subfiles to support
2710 incremental linking. */
2711 static int real_file_count
;
2712 static GTY((length ("real_file_count + 1"))) struct lto_file_decl_data
**real_file_decl_data
;
2714 static void print_lto_report_1 (void);
2716 /* Read all the symbols from the input files FNAMES. NFILES is the
2717 number of files requested in the command line. Instantiate a
2718 global call graph by aggregating all the sub-graphs found in each
2722 read_cgraph_and_symbols (unsigned nfiles
, const char **fnames
)
2724 unsigned int i
, last_file_ix
;
2727 struct lto_file_decl_data
**decl_data
;
2730 symtab
->initialize ();
2732 timevar_push (TV_IPA_LTO_DECL_IN
);
2734 #ifdef ACCEL_COMPILER
2735 section_name_prefix
= OFFLOAD_SECTION_NAME_PREFIX
;
2736 lto_stream_offload_p
= true;
2740 = decl_data
= ggc_cleared_vec_alloc
<lto_file_decl_data_ptr
> (nfiles
+ 1);
2741 real_file_count
= nfiles
;
2743 /* Read the resolution file. */
2745 if (resolution_file_name
)
2748 unsigned num_objects
;
2750 resolution
= fopen (resolution_file_name
, "r");
2751 if (resolution
== NULL
)
2752 fatal_error (input_location
,
2753 "could not open symbol resolution file: %m");
2755 t
= fscanf (resolution
, "%u", &num_objects
);
2756 gcc_assert (t
== 1);
2758 /* True, since the plugin splits the archives. */
2759 gcc_assert (num_objects
== nfiles
);
2761 symtab
->state
= LTO_STREAMING
;
2763 canonical_type_hash_cache
= new hash_map
<const_tree
, hashval_t
> (251);
2764 gimple_canonical_types
= htab_create (16381, gimple_canonical_type_hash
,
2765 gimple_canonical_type_eq
, NULL
);
2766 gcc_obstack_init (&tree_scc_hash_obstack
);
2767 tree_scc_hash
= new hash_table
<tree_scc_hasher
> (4096);
2769 /* Register the common node types with the canonical type machinery so
2770 we properly share alias-sets across languages and TUs. Do not
2771 expose the common nodes as type merge target - those that should be
2772 are already exposed so by pre-loading the LTO streamer caches.
2773 Do two passes - first clear TYPE_CANONICAL and then re-compute it. */
2774 for (i
= 0; i
< itk_none
; ++i
)
2775 lto_register_canonical_types (integer_types
[i
], true);
2776 for (i
= 0; i
< stk_type_kind_last
; ++i
)
2777 lto_register_canonical_types (sizetype_tab
[i
], true);
2778 for (i
= 0; i
< TI_MAX
; ++i
)
2779 lto_register_canonical_types (global_trees
[i
], true);
2780 for (i
= 0; i
< itk_none
; ++i
)
2781 lto_register_canonical_types (integer_types
[i
], false);
2782 for (i
= 0; i
< stk_type_kind_last
; ++i
)
2783 lto_register_canonical_types (sizetype_tab
[i
], false);
2784 for (i
= 0; i
< TI_MAX
; ++i
)
2785 lto_register_canonical_types (global_trees
[i
], false);
2788 fprintf (stderr
, "Reading object files:");
2790 /* Read all of the object files specified on the command line. */
2791 for (i
= 0, last_file_ix
= 0; i
< nfiles
; ++i
)
2793 struct lto_file_decl_data
*file_data
= NULL
;
2796 fprintf (stderr
, " %s", fnames
[i
]);
2800 current_lto_file
= lto_obj_file_open (fnames
[i
], false);
2801 if (!current_lto_file
)
2804 file_data
= lto_file_read (current_lto_file
, resolution
, &count
);
2807 lto_obj_file_close (current_lto_file
);
2808 free (current_lto_file
);
2809 current_lto_file
= NULL
;
2813 decl_data
[last_file_ix
++] = file_data
;
2815 lto_obj_file_close (current_lto_file
);
2816 free (current_lto_file
);
2817 current_lto_file
= NULL
;
2820 lto_flatten_files (decl_data
, count
, last_file_ix
);
2821 lto_stats
.num_input_files
= count
;
2822 ggc_free(decl_data
);
2823 real_file_decl_data
= NULL
;
2825 if (resolution_file_name
)
2826 fclose (resolution
);
2828 /* Show the LTO report before launching LTRANS. */
2829 if (flag_lto_report
|| (flag_wpa
&& flag_lto_report_wpa
))
2830 print_lto_report_1 ();
2832 /* Free gimple type merging datastructures. */
2833 delete tree_scc_hash
;
2834 tree_scc_hash
= NULL
;
2835 obstack_free (&tree_scc_hash_obstack
, NULL
);
2836 htab_delete (gimple_canonical_types
);
2837 gimple_canonical_types
= NULL
;
2838 delete canonical_type_hash_cache
;
2839 canonical_type_hash_cache
= NULL
;
2841 /* At this stage we know that majority of GGC memory is reachable.
2842 Growing the limits prevents unnecesary invocation of GGC. */
2846 /* Set the hooks so that all of the ipa passes can read in their data. */
2847 lto_set_in_hooks (all_file_decl_data
, get_section_data
, free_section_data
);
2849 timevar_pop (TV_IPA_LTO_DECL_IN
);
2852 fprintf (stderr
, "\nReading the callgraph\n");
2854 timevar_push (TV_IPA_LTO_CGRAPH_IO
);
2855 /* Read the symtab. */
2858 input_offload_tables ();
2860 /* Store resolutions into the symbol table. */
2862 ld_plugin_symbol_resolution_t
*res
;
2863 FOR_EACH_SYMBOL (snode
)
2864 if (snode
->real_symbol_p ()
2865 && snode
->lto_file_data
2866 && snode
->lto_file_data
->resolution_map
2867 && (res
= snode
->lto_file_data
->resolution_map
->get (snode
->decl
)))
2868 snode
->resolution
= *res
;
2869 for (i
= 0; all_file_decl_data
[i
]; i
++)
2870 if (all_file_decl_data
[i
]->resolution_map
)
2872 delete all_file_decl_data
[i
]->resolution_map
;
2873 all_file_decl_data
[i
]->resolution_map
= NULL
;
2876 timevar_pop (TV_IPA_LTO_CGRAPH_IO
);
2879 fprintf (stderr
, "Merging declarations\n");
2881 timevar_push (TV_IPA_LTO_DECL_MERGE
);
2882 /* Merge global decls. In ltrans mode we read merged cgraph, we do not
2883 need to care about resolving symbols again, we only need to replace
2884 duplicated declarations read from the callgraph and from function
2888 lto_symtab_merge_decls ();
2890 /* If there were errors during symbol merging bail out, we have no
2891 good way to recover here. */
2893 fatal_error (input_location
,
2894 "errors during merging of translation units");
2896 /* Fixup all decls. */
2897 lto_fixup_decls (all_file_decl_data
);
2900 ggc_free (tree_with_vars
);
2901 tree_with_vars
= NULL
;
2904 timevar_pop (TV_IPA_LTO_DECL_MERGE
);
2905 /* Each pass will set the appropriate timer. */
2908 fprintf (stderr
, "Reading summaries\n");
2910 /* Read the IPA summary data. */
2912 ipa_read_optimization_summaries ();
2914 ipa_read_summaries ();
2916 for (i
= 0; all_file_decl_data
[i
]; i
++)
2918 gcc_assert (all_file_decl_data
[i
]->symtab_node_encoder
);
2919 lto_symtab_encoder_delete (all_file_decl_data
[i
]->symtab_node_encoder
);
2920 all_file_decl_data
[i
]->symtab_node_encoder
= NULL
;
2921 lto_free_function_in_decl_state (all_file_decl_data
[i
]->global_decl_state
);
2922 all_file_decl_data
[i
]->global_decl_state
= NULL
;
2923 all_file_decl_data
[i
]->current_decl_state
= NULL
;
2926 /* Finally merge the cgraph according to the decl merging decisions. */
2927 timevar_push (TV_IPA_LTO_CGRAPH_MERGE
);
2928 if (symtab
->dump_file
)
2930 fprintf (symtab
->dump_file
, "Before merging:\n");
2931 symtab_node::dump_table (symtab
->dump_file
);
2935 lto_symtab_merge_symbols ();
2936 /* Removal of unreachable symbols is needed to make verify_symtab to pass;
2937 we are still having duplicated comdat groups containing local statics.
2938 We could also just remove them while merging. */
2939 symtab
->remove_unreachable_nodes (dump_file
);
2942 symtab
->state
= IPA_SSA
;
2943 /* FIXME: Technically all node removals happening here are useless, because
2944 WPA should not stream them. */
2946 symtab
->remove_unreachable_nodes (dump_file
);
2948 timevar_pop (TV_IPA_LTO_CGRAPH_MERGE
);
2950 /* Indicate that the cgraph is built and ready. */
2951 symtab
->function_flags_ready
= true;
2953 ggc_free (all_file_decl_data
);
2954 all_file_decl_data
= NULL
;
2958 /* Materialize all the bodies for all the nodes in the callgraph. */
2961 materialize_cgraph (void)
2963 struct cgraph_node
*node
;
2964 timevar_id_t lto_timer
;
2968 flag_wpa
? "Materializing decls:" : "Reading function bodies:");
2971 FOR_EACH_FUNCTION (node
)
2973 if (node
->lto_file_data
)
2975 lto_materialize_function (node
);
2976 lto_stats
.num_input_cgraph_nodes
++;
2981 /* Start the appropriate timer depending on the mode that we are
2983 lto_timer
= (flag_wpa
) ? TV_WHOPR_WPA
2984 : (flag_ltrans
) ? TV_WHOPR_LTRANS
2986 timevar_push (lto_timer
);
2988 current_function_decl
= NULL
;
2992 fprintf (stderr
, "\n");
2994 timevar_pop (lto_timer
);
2998 /* Show various memory usage statistics related to LTO. */
3000 print_lto_report_1 (void)
3002 const char *pfx
= (flag_lto
) ? "LTO" : (flag_wpa
) ? "WPA" : "LTRANS";
3003 fprintf (stderr
, "%s statistics\n", pfx
);
3005 fprintf (stderr
, "[%s] read %lu SCCs of average size %f\n",
3006 pfx
, num_sccs_read
, total_scc_size
/ (double)num_sccs_read
);
3007 fprintf (stderr
, "[%s] %lu tree bodies read in total\n", pfx
, total_scc_size
);
3008 if (flag_wpa
&& tree_scc_hash
)
3010 fprintf (stderr
, "[%s] tree SCC table: size %ld, %ld elements, "
3011 "collision ratio: %f\n", pfx
,
3012 (long) tree_scc_hash
->size (),
3013 (long) tree_scc_hash
->elements (),
3014 tree_scc_hash
->collisions ());
3015 hash_table
<tree_scc_hasher
>::iterator hiter
;
3016 tree_scc
*scc
, *max_scc
= NULL
;
3017 unsigned max_length
= 0;
3018 FOR_EACH_HASH_TABLE_ELEMENT (*tree_scc_hash
, scc
, x
, hiter
)
3020 unsigned length
= 0;
3022 for (; s
; s
= s
->next
)
3024 if (length
> max_length
)
3026 max_length
= length
;
3030 fprintf (stderr
, "[%s] tree SCC max chain length %u (size %u)\n",
3031 pfx
, max_length
, max_scc
->len
);
3032 fprintf (stderr
, "[%s] Compared %lu SCCs, %lu collisions (%f)\n", pfx
,
3033 num_scc_compares
, num_scc_compare_collisions
,
3034 num_scc_compare_collisions
/ (double) num_scc_compares
);
3035 fprintf (stderr
, "[%s] Merged %lu SCCs\n", pfx
, num_sccs_merged
);
3036 fprintf (stderr
, "[%s] Merged %lu tree bodies\n", pfx
,
3037 total_scc_size_merged
);
3038 fprintf (stderr
, "[%s] Merged %lu types\n", pfx
, num_merged_types
);
3039 fprintf (stderr
, "[%s] %lu types prevailed (%lu associated trees)\n",
3040 pfx
, num_prevailing_types
, num_type_scc_trees
);
3041 fprintf (stderr
, "[%s] GIMPLE canonical type table: size %ld, "
3042 "%ld elements, %ld searches, %ld collisions (ratio: %f)\n", pfx
,
3043 (long) htab_size (gimple_canonical_types
),
3044 (long) htab_elements (gimple_canonical_types
),
3045 (long) gimple_canonical_types
->searches
,
3046 (long) gimple_canonical_types
->collisions
,
3047 htab_collisions (gimple_canonical_types
));
3048 fprintf (stderr
, "[%s] GIMPLE canonical type pointer-map: "
3049 "%lu elements, %ld searches\n", pfx
,
3050 num_canonical_type_hash_entries
,
3051 num_canonical_type_hash_queries
);
3054 print_lto_report (pfx
);
3057 /* Perform whole program analysis (WPA) on the callgraph and write out the
3058 optimization plan. */
3061 do_whole_program_analysis (void)
3065 lto_parallelism
= 1;
3067 /* TODO: jobserver communicatoin is not supported, yet. */
3068 if (!strcmp (flag_wpa
, "jobserver"))
3069 lto_parallelism
= -1;
3072 lto_parallelism
= atoi (flag_wpa
);
3073 if (lto_parallelism
<= 0)
3074 lto_parallelism
= 0;
3077 timevar_start (TV_PHASE_OPT_GEN
);
3079 /* Note that since we are in WPA mode, materialize_cgraph will not
3080 actually read in all the function bodies. It only materializes
3081 the decls and cgraph nodes so that analysis can be performed. */
3082 materialize_cgraph ();
3084 /* Reading in the cgraph uses different timers, start timing WPA now. */
3085 timevar_push (TV_WHOPR_WPA
);
3087 if (pre_ipa_mem_report
)
3089 fprintf (stderr
, "Memory consumption before IPA\n");
3090 dump_memory_report (false);
3093 symtab
->function_flags_ready
= true;
3095 if (symtab
->dump_file
)
3096 symtab_node::dump_table (symtab
->dump_file
);
3097 bitmap_obstack_initialize (NULL
);
3098 symtab
->state
= IPA_SSA
;
3100 execute_ipa_pass_list (g
->get_passes ()->all_regular_ipa_passes
);
3102 if (symtab
->dump_file
)
3104 fprintf (symtab
->dump_file
, "Optimized ");
3105 symtab_node::dump_table (symtab
->dump_file
);
3108 symtab_node::checking_verify_symtab_nodes ();
3109 bitmap_obstack_release (NULL
);
3111 /* We are about to launch the final LTRANS phase, stop the WPA timer. */
3112 timevar_pop (TV_WHOPR_WPA
);
3114 timevar_push (TV_WHOPR_PARTITIONING
);
3115 if (flag_lto_partition
== LTO_PARTITION_1TO1
)
3117 else if (flag_lto_partition
== LTO_PARTITION_MAX
)
3119 else if (flag_lto_partition
== LTO_PARTITION_ONE
)
3120 lto_balanced_map (1);
3121 else if (flag_lto_partition
== LTO_PARTITION_BALANCED
)
3122 lto_balanced_map (PARAM_VALUE (PARAM_LTO_PARTITIONS
));
3126 /* Inline summaries are needed for balanced partitioning. Free them now so
3127 the memory can be used for streamer caches. */
3128 inline_free_summary ();
3130 /* AUX pointers are used by partitioning code to bookkeep number of
3131 partitions symbol is in. This is no longer needed. */
3132 FOR_EACH_SYMBOL (node
)
3135 lto_stats
.num_cgraph_partitions
+= ltrans_partitions
.length ();
3137 /* Find out statics that need to be promoted
3138 to globals with hidden visibility because they are accessed from multiple
3140 lto_promote_cross_file_statics ();
3141 timevar_pop (TV_WHOPR_PARTITIONING
);
3143 timevar_stop (TV_PHASE_OPT_GEN
);
3145 /* Collect a last time - in lto_wpa_write_files we may end up forking
3146 with the idea that this doesn't increase memory usage. So we
3147 absoultely do not want to collect after that. */
3150 timevar_start (TV_PHASE_STREAM_OUT
);
3153 fprintf (stderr
, "\nStreaming out");
3156 lto_wpa_write_files ();
3158 fprintf (stderr
, "\n");
3159 timevar_stop (TV_PHASE_STREAM_OUT
);
3161 if (post_ipa_mem_report
)
3163 fprintf (stderr
, "Memory consumption after IPA\n");
3164 dump_memory_report (false);
3167 /* Show the LTO report before launching LTRANS. */
3168 if (flag_lto_report
|| (flag_wpa
&& flag_lto_report_wpa
))
3169 print_lto_report_1 ();
3171 dump_memory_report (true);
3175 static GTY(()) tree lto_eh_personality_decl
;
3177 /* Return the LTO personality function decl. */
3180 lto_eh_personality (void)
3182 if (!lto_eh_personality_decl
)
3184 /* Use the first personality DECL for our personality if we don't
3185 support multiple ones. This ensures that we don't artificially
3186 create the need for them in a single-language program. */
3187 if (first_personality_decl
&& !dwarf2out_do_cfi_asm ())
3188 lto_eh_personality_decl
= first_personality_decl
;
3190 lto_eh_personality_decl
= lhd_gcc_personality ();
3193 return lto_eh_personality_decl
;
3196 /* Set the process name based on the LTO mode. */
3199 lto_process_name (void)
3202 setproctitle ("lto1-lto");
3204 setproctitle ("lto1-wpa");
3206 setproctitle ("lto1-ltrans");
3210 /* Initialize the LTO front end. */
3215 lto_process_name ();
3216 lto_streamer_hooks_init ();
3218 lto_set_in_hooks (NULL
, get_section_data
, free_section_data
);
3219 memset (<o_stats
, 0, sizeof (lto_stats
));
3220 bitmap_obstack_initialize (NULL
);
3221 gimple_register_cfg_hooks ();
3222 #ifndef ACCEL_COMPILER
3223 unsigned char *table
3224 = ggc_vec_alloc
<unsigned char> (MAX_MACHINE_MODE
);
3225 for (int m
= 0; m
< MAX_MACHINE_MODE
; m
++)
3227 lto_mode_identity_table
= table
;
3231 /* Create artificial pointers for "omp declare target link" vars. */
3234 offload_handle_link_vars (void)
3236 #ifdef ACCEL_COMPILER
3238 FOR_EACH_VARIABLE (var
)
3239 if (lookup_attribute ("omp declare target link",
3240 DECL_ATTRIBUTES (var
->decl
)))
3242 tree type
= build_pointer_type (TREE_TYPE (var
->decl
));
3243 tree link_ptr_var
= make_node (VAR_DECL
);
3244 TREE_TYPE (link_ptr_var
) = type
;
3245 TREE_USED (link_ptr_var
) = 1;
3246 TREE_STATIC (link_ptr_var
) = 1;
3247 DECL_MODE (link_ptr_var
) = TYPE_MODE (type
);
3248 DECL_SIZE (link_ptr_var
) = TYPE_SIZE (type
);
3249 DECL_SIZE_UNIT (link_ptr_var
) = TYPE_SIZE_UNIT (type
);
3250 DECL_ARTIFICIAL (link_ptr_var
) = 1;
3251 tree var_name
= DECL_ASSEMBLER_NAME (var
->decl
);
3253 = ACONCAT ((IDENTIFIER_POINTER (var_name
), "_linkptr", NULL
));
3254 DECL_NAME (link_ptr_var
) = get_identifier (new_name
);
3255 SET_DECL_ASSEMBLER_NAME (link_ptr_var
, DECL_NAME (link_ptr_var
));
3256 SET_DECL_VALUE_EXPR (var
->decl
, build_simple_mem_ref (link_ptr_var
));
3257 DECL_HAS_VALUE_EXPR_P (var
->decl
) = 1;
3263 /* Main entry point for the GIMPLE front end. This front end has
3264 three main personalities:
3266 - LTO (-flto). All the object files on the command line are
3267 loaded in memory and processed as a single translation unit.
3268 This is the traditional link-time optimization behavior.
3270 - WPA (-fwpa). Only the callgraph and summary information for
3271 files in the command file are loaded. A single callgraph
3272 (without function bodies) is instantiated for the whole set of
3273 files. IPA passes are only allowed to analyze the call graph
3274 and make transformation decisions. The callgraph is
3275 partitioned, each partition is written to a new object file
3276 together with the transformation decisions.
3278 - LTRANS (-fltrans). Similar to -flto but it prevents the IPA
3279 summary files from running again. Since WPA computed summary
3280 information and decided what transformations to apply, LTRANS
3281 simply applies them. */
3286 /* LTO is called as a front end, even though it is not a front end.
3287 Because it is called as a front end, TV_PHASE_PARSING and
3288 TV_PARSE_GLOBAL are active, and we need to turn them off while
3289 doing LTO. Later we turn them back on so they are active up in
3291 timevar_pop (TV_PARSE_GLOBAL
);
3292 timevar_stop (TV_PHASE_PARSING
);
3294 timevar_start (TV_PHASE_SETUP
);
3296 /* Initialize the LTO front end. */
3299 timevar_stop (TV_PHASE_SETUP
);
3300 timevar_start (TV_PHASE_STREAM_IN
);
3302 /* Read all the symbols and call graph from all the files in the
3304 read_cgraph_and_symbols (num_in_fnames
, in_fnames
);
3306 timevar_stop (TV_PHASE_STREAM_IN
);
3310 offload_handle_link_vars ();
3312 /* If WPA is enabled analyze the whole call graph and create an
3313 optimization plan. Otherwise, read in all the function
3314 bodies and continue with optimization. */
3316 do_whole_program_analysis ();
3319 timevar_start (TV_PHASE_OPT_GEN
);
3321 materialize_cgraph ();
3323 lto_promote_statics_nonwpa ();
3325 /* Let the middle end know that we have read and merged all of
3329 timevar_stop (TV_PHASE_OPT_GEN
);
3331 /* FIXME lto, if the processes spawned by WPA fail, we miss
3332 the chance to print WPA's report, so WPA will call
3333 print_lto_report before launching LTRANS. If LTRANS was
3334 launched directly by the driver we would not need to do
3336 if (flag_lto_report
|| (flag_wpa
&& flag_lto_report_wpa
))
3337 print_lto_report_1 ();
3341 /* Here we make LTO pretend to be a parser. */
3342 timevar_start (TV_PHASE_PARSING
);
3343 timevar_push (TV_PARSE_GLOBAL
);
3346 #include "gt-lto-lto.h"