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"
29 #include "double-int.h"
37 #include "fixed-value.h"
39 #include "fold-const.h"
40 #include "stor-layout.h"
41 #include "diagnostic-core.h"
44 #include "basic-block.h"
47 #include "plugin-api.h"
48 #include "hard-reg-set.h"
53 #include "tree-ssa-operands.h"
54 #include "tree-pass.h"
55 #include "langhooks.h"
58 #include "alloc-pool.h"
59 #include "symbol-summary.h"
63 #include "tree-ssa-alias.h"
64 #include "internal-fn.h"
65 #include "gimple-expr.h"
69 #include "lto-streamer.h"
70 #include "lto-section-names.h"
71 #include "tree-streamer.h"
72 #include "splay-tree.h"
73 #include "lto-partition.h"
74 #include "data-streamer.h"
76 #include "pass_manager.h"
77 #include "ipa-inline.h"
79 #include "ipa-utils.h"
80 #include "gomp-constants.h"
83 /* Number of parallel tasks to run, -1 if we want to use GNU Make jobserver. */
84 static int lto_parallelism
;
86 static GTY(()) tree first_personality_decl
;
88 static GTY(()) const unsigned char *lto_mode_identity_table
;
90 /* Returns a hash code for P. */
93 hash_name (const void *p
)
95 const struct lto_section_slot
*ds
= (const struct lto_section_slot
*) p
;
96 return (hashval_t
) htab_hash_string (ds
->name
);
100 /* Returns nonzero if P1 and P2 are equal. */
103 eq_name (const void *p1
, const void *p2
)
105 const struct lto_section_slot
*s1
=
106 (const struct lto_section_slot
*) p1
;
107 const struct lto_section_slot
*s2
=
108 (const struct lto_section_slot
*) p2
;
110 return strcmp (s1
->name
, s2
->name
) == 0;
113 /* Free lto_section_slot */
116 free_with_string (void *arg
)
118 struct lto_section_slot
*s
= (struct lto_section_slot
*)arg
;
120 free (CONST_CAST (char *, s
->name
));
124 /* Create section hash table */
127 lto_obj_create_section_hash_table (void)
129 return htab_create (37, hash_name
, eq_name
, free_with_string
);
132 /* Delete an allocated integer KEY in the splay tree. */
135 lto_splay_tree_delete_id (splay_tree_key key
)
140 /* Compare splay tree node ids A and B. */
143 lto_splay_tree_compare_ids (splay_tree_key a
, splay_tree_key b
)
145 unsigned HOST_WIDE_INT ai
;
146 unsigned HOST_WIDE_INT bi
;
148 ai
= *(unsigned HOST_WIDE_INT
*) a
;
149 bi
= *(unsigned HOST_WIDE_INT
*) b
;
158 /* Look up splay tree node by ID in splay tree T. */
160 static splay_tree_node
161 lto_splay_tree_lookup (splay_tree t
, unsigned HOST_WIDE_INT id
)
163 return splay_tree_lookup (t
, (splay_tree_key
) &id
);
166 /* Check if KEY has ID. */
169 lto_splay_tree_id_equal_p (splay_tree_key key
, unsigned HOST_WIDE_INT id
)
171 return *(unsigned HOST_WIDE_INT
*) key
== id
;
174 /* Insert a splay tree node into tree T with ID as key and FILE_DATA as value.
175 The ID is allocated separately because we need HOST_WIDE_INTs which may
176 be wider than a splay_tree_key. */
179 lto_splay_tree_insert (splay_tree t
, unsigned HOST_WIDE_INT id
,
180 struct lto_file_decl_data
*file_data
)
182 unsigned HOST_WIDE_INT
*idp
= XCNEW (unsigned HOST_WIDE_INT
);
184 splay_tree_insert (t
, (splay_tree_key
) idp
, (splay_tree_value
) file_data
);
187 /* Create a splay tree. */
190 lto_splay_tree_new (void)
192 return splay_tree_new (lto_splay_tree_compare_ids
,
193 lto_splay_tree_delete_id
,
197 /* Return true when NODE has a clone that is analyzed (i.e. we need
198 to load its body even if the node itself is not needed). */
201 has_analyzed_clone_p (struct cgraph_node
*node
)
203 struct cgraph_node
*orig
= node
;
212 else if (node
->next_sibling_clone
)
213 node
= node
->next_sibling_clone
;
216 while (node
!= orig
&& !node
->next_sibling_clone
)
217 node
= node
->clone_of
;
219 node
= node
->next_sibling_clone
;
225 /* Read the function body for the function associated with NODE. */
228 lto_materialize_function (struct cgraph_node
*node
)
233 /* Read in functions with body (analyzed nodes)
234 and also functions that are needed to produce virtual clones. */
235 if ((node
->has_gimple_body_p () && node
->analyzed
)
236 || node
->used_as_abstract_origin
237 || has_analyzed_clone_p (node
))
239 /* Clones don't need to be read. */
242 if (DECL_FUNCTION_PERSONALITY (decl
) && !first_personality_decl
)
243 first_personality_decl
= DECL_FUNCTION_PERSONALITY (decl
);
246 /* Let the middle end know about the function. */
247 rest_of_decl_compilation (decl
, 1, 0);
251 /* Decode the content of memory pointed to by DATA in the in decl
252 state object STATE. DATA_IN points to a data_in structure for
253 decoding. Return the address after the decoded object in the
256 static const uint32_t *
257 lto_read_in_decl_state (struct data_in
*data_in
, const uint32_t *data
,
258 struct lto_in_decl_state
*state
)
265 decl
= streamer_tree_cache_get_tree (data_in
->reader_cache
, ix
);
266 if (!VAR_OR_FUNCTION_DECL_P (decl
))
268 gcc_assert (decl
== void_type_node
);
271 state
->fn_decl
= decl
;
273 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
275 uint32_t size
= *data
++;
276 vec
<tree
, va_gc
> *decls
= NULL
;
277 vec_alloc (decls
, size
);
279 for (j
= 0; j
< size
; j
++)
280 vec_safe_push (decls
,
281 streamer_tree_cache_get_tree (data_in
->reader_cache
,
284 state
->streams
[i
] = decls
;
292 /* Global canonical type table. */
293 static htab_t gimple_canonical_types
;
294 static hash_map
<const_tree
, hashval_t
> *canonical_type_hash_cache
;
295 static unsigned long num_canonical_type_hash_entries
;
296 static unsigned long num_canonical_type_hash_queries
;
298 static void iterative_hash_canonical_type (tree type
, inchash::hash
&hstate
);
299 static hashval_t
gimple_canonical_type_hash (const void *p
);
300 static void gimple_register_canonical_type_1 (tree t
, hashval_t hash
);
302 /* Returning a hash value for gimple type TYPE.
304 The hash value returned is equal for types considered compatible
305 by gimple_canonical_types_compatible_p. */
308 hash_canonical_type (tree type
)
310 inchash::hash hstate
;
312 /* Combine a few common features of types so that types are grouped into
313 smaller sets; when searching for existing matching types to merge,
314 only existing types having the same features as the new type will be
316 hstate
.add_int (TREE_CODE (type
));
317 hstate
.add_int (TYPE_MODE (type
));
319 /* Incorporate common features of numerical types. */
320 if (INTEGRAL_TYPE_P (type
)
321 || SCALAR_FLOAT_TYPE_P (type
)
322 || FIXED_POINT_TYPE_P (type
)
323 || TREE_CODE (type
) == OFFSET_TYPE
324 || POINTER_TYPE_P (type
))
326 hstate
.add_int (TYPE_UNSIGNED (type
));
327 hstate
.add_int (TYPE_PRECISION (type
));
330 if (VECTOR_TYPE_P (type
))
332 hstate
.add_int (TYPE_VECTOR_SUBPARTS (type
));
333 hstate
.add_int (TYPE_UNSIGNED (type
));
336 if (TREE_CODE (type
) == COMPLEX_TYPE
)
337 hstate
.add_int (TYPE_UNSIGNED (type
));
339 /* For pointer and reference types, fold in information about the type
340 pointed to but do not recurse to the pointed-to type. */
341 if (POINTER_TYPE_P (type
))
343 hstate
.add_int (TYPE_ADDR_SPACE (TREE_TYPE (type
)));
344 hstate
.add_int (TREE_CODE (TREE_TYPE (type
)));
347 /* For integer types hash only the string flag. */
348 if (TREE_CODE (type
) == INTEGER_TYPE
)
349 hstate
.add_int (TYPE_STRING_FLAG (type
));
351 /* For array types hash the domain bounds and the string flag. */
352 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
354 hstate
.add_int (TYPE_STRING_FLAG (type
));
355 /* OMP lowering can introduce error_mark_node in place of
356 random local decls in types. */
357 if (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)) != error_mark_node
)
358 inchash::add_expr (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)), hstate
);
359 if (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != error_mark_node
)
360 inchash::add_expr (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)), hstate
);
363 /* Recurse for aggregates with a single element type. */
364 if (TREE_CODE (type
) == ARRAY_TYPE
365 || TREE_CODE (type
) == COMPLEX_TYPE
366 || TREE_CODE (type
) == VECTOR_TYPE
)
367 iterative_hash_canonical_type (TREE_TYPE (type
), hstate
);
369 /* Incorporate function return and argument types. */
370 if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
375 /* For method types also incorporate their parent class. */
376 if (TREE_CODE (type
) == METHOD_TYPE
)
377 iterative_hash_canonical_type (TYPE_METHOD_BASETYPE (type
), hstate
);
379 iterative_hash_canonical_type (TREE_TYPE (type
), hstate
);
381 for (p
= TYPE_ARG_TYPES (type
), na
= 0; p
; p
= TREE_CHAIN (p
))
383 iterative_hash_canonical_type (TREE_VALUE (p
), hstate
);
390 if (RECORD_OR_UNION_TYPE_P (type
))
395 for (f
= TYPE_FIELDS (type
), nf
= 0; f
; f
= TREE_CHAIN (f
))
396 if (TREE_CODE (f
) == FIELD_DECL
)
398 iterative_hash_canonical_type (TREE_TYPE (f
), hstate
);
408 /* Returning a hash value for gimple type TYPE combined with VAL. */
411 iterative_hash_canonical_type (tree type
, inchash::hash
&hstate
)
414 /* An already processed type. */
415 if (TYPE_CANONICAL (type
))
417 type
= TYPE_CANONICAL (type
);
418 v
= gimple_canonical_type_hash (type
);
422 /* Canonical types should not be able to form SCCs by design, this
423 recursion is just because we do not register canonical types in
424 optimal order. To avoid quadratic behavior also register the
426 v
= hash_canonical_type (type
);
427 gimple_register_canonical_type_1 (type
, v
);
432 /* Returns the hash for a canonical type P. */
435 gimple_canonical_type_hash (const void *p
)
437 num_canonical_type_hash_queries
++;
438 hashval_t
*slot
= canonical_type_hash_cache
->get ((const_tree
) p
);
439 gcc_assert (slot
!= NULL
);
445 /* Returns nonzero if P1 and P2 are equal. */
448 gimple_canonical_type_eq (const void *p1
, const void *p2
)
450 const_tree t1
= (const_tree
) p1
;
451 const_tree t2
= (const_tree
) p2
;
452 return gimple_canonical_types_compatible_p (CONST_CAST_TREE (t1
),
453 CONST_CAST_TREE (t2
));
456 /* Main worker for gimple_register_canonical_type. */
459 gimple_register_canonical_type_1 (tree t
, hashval_t hash
)
463 gcc_checking_assert (TYPE_P (t
) && !TYPE_CANONICAL (t
));
465 slot
= htab_find_slot_with_hash (gimple_canonical_types
, t
, hash
, INSERT
);
468 tree new_type
= (tree
)(*slot
);
469 gcc_checking_assert (new_type
!= t
);
470 TYPE_CANONICAL (t
) = new_type
;
474 TYPE_CANONICAL (t
) = t
;
476 /* Cache the just computed hash value. */
477 num_canonical_type_hash_entries
++;
478 bool existed_p
= canonical_type_hash_cache
->put (t
, hash
);
479 gcc_assert (!existed_p
);
483 /* Register type T in the global type table gimple_types and set
484 TYPE_CANONICAL of T accordingly.
485 This is used by LTO to merge structurally equivalent types for
486 type-based aliasing purposes across different TUs and languages.
488 ??? This merging does not exactly match how the tree.c middle-end
489 functions will assign TYPE_CANONICAL when new types are created
490 during optimization (which at least happens for pointer and array
494 gimple_register_canonical_type (tree t
)
496 if (TYPE_CANONICAL (t
))
499 gimple_register_canonical_type_1 (t
, hash_canonical_type (t
));
502 /* Re-compute TYPE_CANONICAL for NODE and related types. */
505 lto_register_canonical_types (tree node
, bool first_p
)
512 TYPE_CANONICAL (node
) = NULL_TREE
;
514 if (POINTER_TYPE_P (node
)
515 || TREE_CODE (node
) == COMPLEX_TYPE
516 || TREE_CODE (node
) == ARRAY_TYPE
)
517 lto_register_canonical_types (TREE_TYPE (node
), first_p
);
520 gimple_register_canonical_type (node
);
524 /* Remember trees that contains references to declarations. */
525 static GTY(()) vec
<tree
, va_gc
> *tree_with_vars
;
527 #define CHECK_VAR(tt) \
530 if ((tt) && VAR_OR_FUNCTION_DECL_P (tt) \
531 && (TREE_PUBLIC (tt) || DECL_EXTERNAL (tt))) \
535 #define CHECK_NO_VAR(tt) \
536 gcc_checking_assert (!(tt) || !VAR_OR_FUNCTION_DECL_P (tt))
538 /* Check presence of pointers to decls in fields of a tree_typed T. */
541 mentions_vars_p_typed (tree t
)
543 CHECK_NO_VAR (TREE_TYPE (t
));
547 /* Check presence of pointers to decls in fields of a tree_common T. */
550 mentions_vars_p_common (tree t
)
552 if (mentions_vars_p_typed (t
))
554 CHECK_NO_VAR (TREE_CHAIN (t
));
558 /* Check presence of pointers to decls in fields of a decl_minimal T. */
561 mentions_vars_p_decl_minimal (tree t
)
563 if (mentions_vars_p_common (t
))
565 CHECK_NO_VAR (DECL_NAME (t
));
566 CHECK_VAR (DECL_CONTEXT (t
));
570 /* Check presence of pointers to decls in fields of a decl_common T. */
573 mentions_vars_p_decl_common (tree t
)
575 if (mentions_vars_p_decl_minimal (t
))
577 CHECK_VAR (DECL_SIZE (t
));
578 CHECK_VAR (DECL_SIZE_UNIT (t
));
579 CHECK_VAR (DECL_INITIAL (t
));
580 CHECK_NO_VAR (DECL_ATTRIBUTES (t
));
581 CHECK_VAR (DECL_ABSTRACT_ORIGIN (t
));
585 /* Check presence of pointers to decls in fields of a decl_with_vis T. */
588 mentions_vars_p_decl_with_vis (tree t
)
590 if (mentions_vars_p_decl_common (t
))
593 /* Accessor macro has side-effects, use field-name here. */
594 CHECK_NO_VAR (t
->decl_with_vis
.assembler_name
);
598 /* Check presence of pointers to decls in fields of a decl_non_common T. */
601 mentions_vars_p_decl_non_common (tree t
)
603 if (mentions_vars_p_decl_with_vis (t
))
605 CHECK_NO_VAR (DECL_RESULT_FLD (t
));
609 /* Check presence of pointers to decls in fields of a decl_non_common T. */
612 mentions_vars_p_function (tree t
)
614 if (mentions_vars_p_decl_non_common (t
))
616 CHECK_NO_VAR (DECL_ARGUMENTS (t
));
617 CHECK_NO_VAR (DECL_VINDEX (t
));
618 CHECK_VAR (DECL_FUNCTION_PERSONALITY (t
));
622 /* Check presence of pointers to decls in fields of a field_decl T. */
625 mentions_vars_p_field_decl (tree t
)
627 if (mentions_vars_p_decl_common (t
))
629 CHECK_VAR (DECL_FIELD_OFFSET (t
));
630 CHECK_NO_VAR (DECL_BIT_FIELD_TYPE (t
));
631 CHECK_NO_VAR (DECL_QUALIFIER (t
));
632 CHECK_NO_VAR (DECL_FIELD_BIT_OFFSET (t
));
633 CHECK_NO_VAR (DECL_FCONTEXT (t
));
637 /* Check presence of pointers to decls in fields of a type T. */
640 mentions_vars_p_type (tree t
)
642 if (mentions_vars_p_common (t
))
644 CHECK_NO_VAR (TYPE_CACHED_VALUES (t
));
645 CHECK_VAR (TYPE_SIZE (t
));
646 CHECK_VAR (TYPE_SIZE_UNIT (t
));
647 CHECK_NO_VAR (TYPE_ATTRIBUTES (t
));
648 CHECK_NO_VAR (TYPE_NAME (t
));
650 CHECK_VAR (TYPE_MINVAL (t
));
651 CHECK_VAR (TYPE_MAXVAL (t
));
653 /* Accessor is for derived node types only. */
654 CHECK_NO_VAR (t
->type_non_common
.binfo
);
656 CHECK_VAR (TYPE_CONTEXT (t
));
657 CHECK_NO_VAR (TYPE_CANONICAL (t
));
658 CHECK_NO_VAR (TYPE_MAIN_VARIANT (t
));
659 CHECK_NO_VAR (TYPE_NEXT_VARIANT (t
));
663 /* Check presence of pointers to decls in fields of a BINFO T. */
666 mentions_vars_p_binfo (tree t
)
668 unsigned HOST_WIDE_INT i
, n
;
670 if (mentions_vars_p_common (t
))
672 CHECK_VAR (BINFO_VTABLE (t
));
673 CHECK_NO_VAR (BINFO_OFFSET (t
));
674 CHECK_NO_VAR (BINFO_VIRTUALS (t
));
675 CHECK_NO_VAR (BINFO_VPTR_FIELD (t
));
676 n
= vec_safe_length (BINFO_BASE_ACCESSES (t
));
677 for (i
= 0; i
< n
; i
++)
678 CHECK_NO_VAR (BINFO_BASE_ACCESS (t
, i
));
679 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
680 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
681 n
= BINFO_N_BASE_BINFOS (t
);
682 for (i
= 0; i
< n
; i
++)
683 CHECK_NO_VAR (BINFO_BASE_BINFO (t
, i
));
687 /* Check presence of pointers to decls in fields of a CONSTRUCTOR T. */
690 mentions_vars_p_constructor (tree t
)
692 unsigned HOST_WIDE_INT idx
;
695 if (mentions_vars_p_typed (t
))
698 for (idx
= 0; vec_safe_iterate (CONSTRUCTOR_ELTS (t
), idx
, &ce
); idx
++)
700 CHECK_NO_VAR (ce
->index
);
701 CHECK_VAR (ce
->value
);
706 /* Check presence of pointers to decls in fields of an expression tree T. */
709 mentions_vars_p_expr (tree t
)
712 if (mentions_vars_p_typed (t
))
714 for (i
= TREE_OPERAND_LENGTH (t
) - 1; i
>= 0; --i
)
715 CHECK_VAR (TREE_OPERAND (t
, i
));
719 /* Check presence of pointers to decls in fields of an OMP_CLAUSE T. */
722 mentions_vars_p_omp_clause (tree t
)
725 if (mentions_vars_p_common (t
))
727 for (i
= omp_clause_num_ops
[OMP_CLAUSE_CODE (t
)] - 1; i
>= 0; --i
)
728 CHECK_VAR (OMP_CLAUSE_OPERAND (t
, i
));
732 /* Check presence of pointers to decls that needs later fixup in T. */
735 mentions_vars_p (tree t
)
737 switch (TREE_CODE (t
))
739 case IDENTIFIER_NODE
:
743 CHECK_VAR (TREE_VALUE (t
));
744 CHECK_VAR (TREE_PURPOSE (t
));
745 CHECK_NO_VAR (TREE_CHAIN (t
));
749 return mentions_vars_p_field_decl (t
);
758 return mentions_vars_p_decl_common (t
);
761 return mentions_vars_p_decl_with_vis (t
);
764 return mentions_vars_p_decl_non_common (t
);
767 return mentions_vars_p_function (t
);
770 return mentions_vars_p_binfo (t
);
772 case PLACEHOLDER_EXPR
:
773 return mentions_vars_p_common (t
);
776 case TRANSLATION_UNIT_DECL
:
777 case OPTIMIZATION_NODE
:
778 case TARGET_OPTION_NODE
:
782 return mentions_vars_p_constructor (t
);
785 return mentions_vars_p_omp_clause (t
);
790 if (mentions_vars_p_type (t
))
795 if (mentions_vars_p_expr (t
))
798 else if (CONSTANT_CLASS_P (t
))
799 CHECK_NO_VAR (TREE_TYPE (t
));
807 /* Return the resolution for the decl with index INDEX from DATA_IN. */
809 static enum ld_plugin_symbol_resolution
810 get_resolution (struct data_in
*data_in
, unsigned index
)
812 if (data_in
->globals_resolution
.exists ())
814 ld_plugin_symbol_resolution_t ret
;
815 /* We can have references to not emitted functions in
816 DECL_FUNCTION_PERSONALITY at least. So we can and have
817 to indeed return LDPR_UNKNOWN in some cases. */
818 if (data_in
->globals_resolution
.length () <= index
)
820 ret
= data_in
->globals_resolution
[index
];
824 /* Delay resolution finding until decl merging. */
828 /* We need to record resolutions until symbol table is read. */
830 register_resolution (struct lto_file_decl_data
*file_data
, tree decl
,
831 enum ld_plugin_symbol_resolution resolution
)
833 if (resolution
== LDPR_UNKNOWN
)
835 if (!file_data
->resolution_map
)
836 file_data
->resolution_map
837 = new hash_map
<tree
, ld_plugin_symbol_resolution
>;
838 file_data
->resolution_map
->put (decl
, resolution
);
841 /* Register DECL with the global symbol table and change its
842 name if necessary to avoid name clashes for static globals across
846 lto_register_var_decl_in_symtab (struct data_in
*data_in
, tree decl
,
851 /* Variable has file scope, not local. */
852 if (!TREE_PUBLIC (decl
)
853 && !((context
= decl_function_context (decl
))
854 && auto_var_in_fn_p (decl
, context
)))
855 rest_of_decl_compilation (decl
, 1, 0);
857 /* If this variable has already been declared, queue the
858 declaration for merging. */
859 if (TREE_PUBLIC (decl
))
860 register_resolution (data_in
->file_data
,
861 decl
, get_resolution (data_in
, ix
));
865 /* Register DECL with the global symbol table and change its
866 name if necessary to avoid name clashes for static globals across
867 different files. DATA_IN contains descriptors and tables for the
871 lto_register_function_decl_in_symtab (struct data_in
*data_in
, tree decl
,
874 /* If this variable has already been declared, queue the
875 declaration for merging. */
876 if (TREE_PUBLIC (decl
) && !DECL_ABSTRACT_P (decl
))
877 register_resolution (data_in
->file_data
,
878 decl
, get_resolution (data_in
, ix
));
882 /* For the type T re-materialize it in the type variant list and
883 the pointer/reference-to chains. */
886 lto_fixup_prevailing_type (tree t
)
888 /* The following re-creates proper variant lists while fixing up
889 the variant leaders. We do not stream TYPE_NEXT_VARIANT so the
890 variant list state before fixup is broken. */
892 /* If we are not our own variant leader link us into our new leaders
894 if (TYPE_MAIN_VARIANT (t
) != t
)
896 tree mv
= TYPE_MAIN_VARIANT (t
);
897 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (mv
);
898 TYPE_NEXT_VARIANT (mv
) = t
;
901 /* The following reconstructs the pointer chains
902 of the new pointed-to type if we are a main variant. We do
903 not stream those so they are broken before fixup. */
904 if (TREE_CODE (t
) == POINTER_TYPE
905 && TYPE_MAIN_VARIANT (t
) == t
)
907 TYPE_NEXT_PTR_TO (t
) = TYPE_POINTER_TO (TREE_TYPE (t
));
908 TYPE_POINTER_TO (TREE_TYPE (t
)) = t
;
910 else if (TREE_CODE (t
) == REFERENCE_TYPE
911 && TYPE_MAIN_VARIANT (t
) == t
)
913 TYPE_NEXT_REF_TO (t
) = TYPE_REFERENCE_TO (TREE_TYPE (t
));
914 TYPE_REFERENCE_TO (TREE_TYPE (t
)) = t
;
919 /* We keep prevailing tree SCCs in a hashtable with manual collision
920 handling (in case all hashes compare the same) and keep the colliding
921 entries in the tree_scc->next chain. */
926 /* Hash of the whole SCC. */
928 /* Number of trees in the SCC. */
930 /* Number of possible entries into the SCC (tree nodes [0..entry_len-1]
931 which share the same individual tree hash). */
933 /* The members of the SCC.
934 We only need to remember the first entry node candidate for prevailing
935 SCCs (but of course have access to all entries for SCCs we are
937 ??? For prevailing SCCs we really only need hash and the first
938 entry candidate, but that's too awkward to implement. */
942 struct tree_scc_hasher
: typed_noop_remove
<tree_scc
>
944 typedef tree_scc
*value_type
;
945 typedef tree_scc
*compare_type
;
946 static inline hashval_t
hash (const tree_scc
*);
947 static inline bool equal (const tree_scc
*, const tree_scc
*);
951 tree_scc_hasher::hash (const tree_scc
*scc
)
957 tree_scc_hasher::equal (const tree_scc
*scc1
, const tree_scc
*scc2
)
959 if (scc1
->hash
!= scc2
->hash
960 || scc1
->len
!= scc2
->len
961 || scc1
->entry_len
!= scc2
->entry_len
)
966 static hash_table
<tree_scc_hasher
> *tree_scc_hash
;
967 static struct obstack tree_scc_hash_obstack
;
969 static unsigned long num_merged_types
;
970 static unsigned long num_prevailing_types
;
971 static unsigned long num_type_scc_trees
;
972 static unsigned long total_scc_size
;
973 static unsigned long num_sccs_read
;
974 static unsigned long total_scc_size_merged
;
975 static unsigned long num_sccs_merged
;
976 static unsigned long num_scc_compares
;
977 static unsigned long num_scc_compare_collisions
;
980 /* Compare the two entries T1 and T2 of two SCCs that are possibly equal,
981 recursing through in-SCC tree edges. Returns true if the SCCs entered
982 through T1 and T2 are equal and fills in *MAP with the pairs of
983 SCC entries we visited, starting with (*MAP)[0] = T1 and (*MAP)[1] = T2. */
986 compare_tree_sccs_1 (tree t1
, tree t2
, tree
**map
)
990 /* Mark already visited nodes. */
991 TREE_ASM_WRITTEN (t2
) = 1;
993 /* Push the pair onto map. */
998 /* Compare value-fields. */
999 #define compare_values(X) \
1001 if (X(t1) != X(t2)) \
1005 compare_values (TREE_CODE
);
1006 code
= TREE_CODE (t1
);
1010 compare_values (TREE_SIDE_EFFECTS
);
1011 compare_values (TREE_CONSTANT
);
1012 compare_values (TREE_READONLY
);
1013 compare_values (TREE_PUBLIC
);
1015 compare_values (TREE_ADDRESSABLE
);
1016 compare_values (TREE_THIS_VOLATILE
);
1018 compare_values (DECL_UNSIGNED
);
1019 else if (TYPE_P (t1
))
1020 compare_values (TYPE_UNSIGNED
);
1022 compare_values (TYPE_ARTIFICIAL
);
1024 compare_values (TREE_NO_WARNING
);
1025 compare_values (TREE_NOTHROW
);
1026 compare_values (TREE_STATIC
);
1027 if (code
!= TREE_BINFO
)
1028 compare_values (TREE_PRIVATE
);
1029 compare_values (TREE_PROTECTED
);
1030 compare_values (TREE_DEPRECATED
);
1033 compare_values (TYPE_SATURATING
);
1034 compare_values (TYPE_ADDR_SPACE
);
1036 else if (code
== SSA_NAME
)
1037 compare_values (SSA_NAME_IS_DEFAULT_DEF
);
1039 if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
1041 if (!wi::eq_p (t1
, t2
))
1045 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
1047 /* ??? No suitable compare routine available. */
1048 REAL_VALUE_TYPE r1
= TREE_REAL_CST (t1
);
1049 REAL_VALUE_TYPE r2
= TREE_REAL_CST (t2
);
1051 || r1
.decimal
!= r2
.decimal
1052 || r1
.sign
!= r2
.sign
1053 || r1
.signalling
!= r2
.signalling
1054 || r1
.canonical
!= r2
.canonical
1055 || r1
.uexp
!= r2
.uexp
)
1057 for (unsigned i
= 0; i
< SIGSZ
; ++i
)
1058 if (r1
.sig
[i
] != r2
.sig
[i
])
1062 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
1063 if (!fixed_compare (EQ_EXPR
,
1064 TREE_FIXED_CST_PTR (t1
), TREE_FIXED_CST_PTR (t2
)))
1068 /* We don't want to compare locations, so there is nothing do compare
1069 for TS_DECL_MINIMAL. */
1071 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1073 compare_values (DECL_MODE
);
1074 compare_values (DECL_NONLOCAL
);
1075 compare_values (DECL_VIRTUAL_P
);
1076 compare_values (DECL_IGNORED_P
);
1077 compare_values (DECL_ABSTRACT_P
);
1078 compare_values (DECL_ARTIFICIAL
);
1079 compare_values (DECL_USER_ALIGN
);
1080 compare_values (DECL_PRESERVE_P
);
1081 compare_values (DECL_EXTERNAL
);
1082 compare_values (DECL_GIMPLE_REG_P
);
1083 compare_values (DECL_ALIGN
);
1084 if (code
== LABEL_DECL
)
1086 compare_values (EH_LANDING_PAD_NR
);
1087 compare_values (LABEL_DECL_UID
);
1089 else if (code
== FIELD_DECL
)
1091 compare_values (DECL_PACKED
);
1092 compare_values (DECL_NONADDRESSABLE_P
);
1093 compare_values (DECL_OFFSET_ALIGN
);
1095 else if (code
== VAR_DECL
)
1097 compare_values (DECL_HAS_DEBUG_EXPR_P
);
1098 compare_values (DECL_NONLOCAL_FRAME
);
1100 if (code
== RESULT_DECL
1101 || code
== PARM_DECL
1102 || code
== VAR_DECL
)
1104 compare_values (DECL_BY_REFERENCE
);
1105 if (code
== VAR_DECL
1106 || code
== PARM_DECL
)
1107 compare_values (DECL_HAS_VALUE_EXPR_P
);
1111 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
1112 compare_values (DECL_REGISTER
);
1114 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1116 compare_values (DECL_COMMON
);
1117 compare_values (DECL_DLLIMPORT_P
);
1118 compare_values (DECL_WEAK
);
1119 compare_values (DECL_SEEN_IN_BIND_EXPR_P
);
1120 compare_values (DECL_COMDAT
);
1121 compare_values (DECL_VISIBILITY
);
1122 compare_values (DECL_VISIBILITY_SPECIFIED
);
1123 if (code
== VAR_DECL
)
1125 compare_values (DECL_HARD_REGISTER
);
1126 /* DECL_IN_TEXT_SECTION is set during final asm output only. */
1127 compare_values (DECL_IN_CONSTANT_POOL
);
1131 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1133 compare_values (DECL_BUILT_IN_CLASS
);
1134 compare_values (DECL_STATIC_CONSTRUCTOR
);
1135 compare_values (DECL_STATIC_DESTRUCTOR
);
1136 compare_values (DECL_UNINLINABLE
);
1137 compare_values (DECL_POSSIBLY_INLINED
);
1138 compare_values (DECL_IS_NOVOPS
);
1139 compare_values (DECL_IS_RETURNS_TWICE
);
1140 compare_values (DECL_IS_MALLOC
);
1141 compare_values (DECL_IS_OPERATOR_NEW
);
1142 compare_values (DECL_DECLARED_INLINE_P
);
1143 compare_values (DECL_STATIC_CHAIN
);
1144 compare_values (DECL_NO_INLINE_WARNING_P
);
1145 compare_values (DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT
);
1146 compare_values (DECL_NO_LIMIT_STACK
);
1147 compare_values (DECL_DISREGARD_INLINE_LIMITS
);
1148 compare_values (DECL_PURE_P
);
1149 compare_values (DECL_LOOPING_CONST_OR_PURE_P
);
1150 compare_values (DECL_FINAL_P
);
1151 compare_values (DECL_CXX_CONSTRUCTOR_P
);
1152 compare_values (DECL_CXX_DESTRUCTOR_P
);
1153 if (DECL_BUILT_IN_CLASS (t1
) != NOT_BUILT_IN
)
1154 compare_values (DECL_FUNCTION_CODE
);
1157 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
1159 compare_values (TYPE_MODE
);
1160 compare_values (TYPE_STRING_FLAG
);
1161 compare_values (TYPE_NO_FORCE_BLK
);
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"