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"
30 #include "fold-const.h"
31 #include "stor-layout.h"
32 #include "diagnostic-core.h"
35 #include "basic-block.h"
36 #include "plugin-api.h"
37 #include "hard-reg-set.h"
41 #include "tree-ssa-operands.h"
42 #include "tree-pass.h"
43 #include "langhooks.h"
45 #include "alloc-pool.h"
46 #include "symbol-summary.h"
50 #include "tree-ssa-alias.h"
51 #include "internal-fn.h"
52 #include "gimple-expr.h"
56 #include "lto-streamer.h"
57 #include "lto-section-names.h"
58 #include "tree-streamer.h"
59 #include "splay-tree.h"
60 #include "lto-partition.h"
61 #include "data-streamer.h"
63 #include "pass_manager.h"
64 #include "ipa-inline.h"
66 #include "ipa-utils.h"
67 #include "gomp-constants.h"
70 /* Number of parallel tasks to run, -1 if we want to use GNU Make jobserver. */
71 static int lto_parallelism
;
73 static GTY(()) tree first_personality_decl
;
75 static GTY(()) const unsigned char *lto_mode_identity_table
;
77 /* Returns a hash code for P. */
80 hash_name (const void *p
)
82 const struct lto_section_slot
*ds
= (const struct lto_section_slot
*) p
;
83 return (hashval_t
) htab_hash_string (ds
->name
);
87 /* Returns nonzero if P1 and P2 are equal. */
90 eq_name (const void *p1
, const void *p2
)
92 const struct lto_section_slot
*s1
=
93 (const struct lto_section_slot
*) p1
;
94 const struct lto_section_slot
*s2
=
95 (const struct lto_section_slot
*) p2
;
97 return strcmp (s1
->name
, s2
->name
) == 0;
100 /* Free lto_section_slot */
103 free_with_string (void *arg
)
105 struct lto_section_slot
*s
= (struct lto_section_slot
*)arg
;
107 free (CONST_CAST (char *, s
->name
));
111 /* Create section hash table */
114 lto_obj_create_section_hash_table (void)
116 return htab_create (37, hash_name
, eq_name
, free_with_string
);
119 /* Delete an allocated integer KEY in the splay tree. */
122 lto_splay_tree_delete_id (splay_tree_key key
)
127 /* Compare splay tree node ids A and B. */
130 lto_splay_tree_compare_ids (splay_tree_key a
, splay_tree_key b
)
132 unsigned HOST_WIDE_INT ai
;
133 unsigned HOST_WIDE_INT bi
;
135 ai
= *(unsigned HOST_WIDE_INT
*) a
;
136 bi
= *(unsigned HOST_WIDE_INT
*) b
;
145 /* Look up splay tree node by ID in splay tree T. */
147 static splay_tree_node
148 lto_splay_tree_lookup (splay_tree t
, unsigned HOST_WIDE_INT id
)
150 return splay_tree_lookup (t
, (splay_tree_key
) &id
);
153 /* Check if KEY has ID. */
156 lto_splay_tree_id_equal_p (splay_tree_key key
, unsigned HOST_WIDE_INT id
)
158 return *(unsigned HOST_WIDE_INT
*) key
== id
;
161 /* Insert a splay tree node into tree T with ID as key and FILE_DATA as value.
162 The ID is allocated separately because we need HOST_WIDE_INTs which may
163 be wider than a splay_tree_key. */
166 lto_splay_tree_insert (splay_tree t
, unsigned HOST_WIDE_INT id
,
167 struct lto_file_decl_data
*file_data
)
169 unsigned HOST_WIDE_INT
*idp
= XCNEW (unsigned HOST_WIDE_INT
);
171 splay_tree_insert (t
, (splay_tree_key
) idp
, (splay_tree_value
) file_data
);
174 /* Create a splay tree. */
177 lto_splay_tree_new (void)
179 return splay_tree_new (lto_splay_tree_compare_ids
,
180 lto_splay_tree_delete_id
,
184 /* Return true when NODE has a clone that is analyzed (i.e. we need
185 to load its body even if the node itself is not needed). */
188 has_analyzed_clone_p (struct cgraph_node
*node
)
190 struct cgraph_node
*orig
= node
;
199 else if (node
->next_sibling_clone
)
200 node
= node
->next_sibling_clone
;
203 while (node
!= orig
&& !node
->next_sibling_clone
)
204 node
= node
->clone_of
;
206 node
= node
->next_sibling_clone
;
212 /* Read the function body for the function associated with NODE. */
215 lto_materialize_function (struct cgraph_node
*node
)
220 /* Read in functions with body (analyzed nodes)
221 and also functions that are needed to produce virtual clones. */
222 if ((node
->has_gimple_body_p () && node
->analyzed
)
223 || node
->used_as_abstract_origin
224 || has_analyzed_clone_p (node
))
226 /* Clones don't need to be read. */
229 if (DECL_FUNCTION_PERSONALITY (decl
) && !first_personality_decl
)
230 first_personality_decl
= DECL_FUNCTION_PERSONALITY (decl
);
233 /* Let the middle end know about the function. */
234 rest_of_decl_compilation (decl
, 1, 0);
238 /* Decode the content of memory pointed to by DATA in the in decl
239 state object STATE. DATA_IN points to a data_in structure for
240 decoding. Return the address after the decoded object in the
243 static const uint32_t *
244 lto_read_in_decl_state (struct data_in
*data_in
, const uint32_t *data
,
245 struct lto_in_decl_state
*state
)
252 decl
= streamer_tree_cache_get_tree (data_in
->reader_cache
, ix
);
253 if (!VAR_OR_FUNCTION_DECL_P (decl
))
255 gcc_assert (decl
== void_type_node
);
258 state
->fn_decl
= decl
;
260 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
262 uint32_t size
= *data
++;
263 vec
<tree
, va_gc
> *decls
= NULL
;
264 vec_alloc (decls
, size
);
266 for (j
= 0; j
< size
; j
++)
267 vec_safe_push (decls
,
268 streamer_tree_cache_get_tree (data_in
->reader_cache
,
271 state
->streams
[i
] = decls
;
279 /* Global canonical type table. */
280 static htab_t gimple_canonical_types
;
281 static hash_map
<const_tree
, hashval_t
> *canonical_type_hash_cache
;
282 static unsigned long num_canonical_type_hash_entries
;
283 static unsigned long num_canonical_type_hash_queries
;
285 static void iterative_hash_canonical_type (tree type
, inchash::hash
&hstate
);
286 static hashval_t
gimple_canonical_type_hash (const void *p
);
287 static void gimple_register_canonical_type_1 (tree t
, hashval_t hash
);
289 /* Returning a hash value for gimple type TYPE.
291 The hash value returned is equal for types considered compatible
292 by gimple_canonical_types_compatible_p. */
295 hash_canonical_type (tree type
)
297 inchash::hash hstate
;
299 /* We compute alias sets only for types that needs them.
300 Be sure we do not recurse to something else as we can not hash incomplete
301 types in a way they would have same hash value as compatible complete
303 gcc_checking_assert (type_with_alias_set_p (type
));
305 /* Combine a few common features of types so that types are grouped into
306 smaller sets; when searching for existing matching types to merge,
307 only existing types having the same features as the new type will be
309 hstate
.add_int (tree_code_for_canonical_type_merging (TREE_CODE (type
)));
310 hstate
.add_int (TYPE_MODE (type
));
312 /* Incorporate common features of numerical types. */
313 if (INTEGRAL_TYPE_P (type
)
314 || SCALAR_FLOAT_TYPE_P (type
)
315 || FIXED_POINT_TYPE_P (type
)
316 || TREE_CODE (type
) == OFFSET_TYPE
317 || POINTER_TYPE_P (type
))
319 hstate
.add_int (TYPE_UNSIGNED (type
));
320 hstate
.add_int (TYPE_PRECISION (type
));
323 if (VECTOR_TYPE_P (type
))
325 hstate
.add_int (TYPE_VECTOR_SUBPARTS (type
));
326 hstate
.add_int (TYPE_UNSIGNED (type
));
329 if (TREE_CODE (type
) == COMPLEX_TYPE
)
330 hstate
.add_int (TYPE_UNSIGNED (type
));
332 /* Fortran's C_SIGNED_CHAR is !TYPE_STRING_FLAG but needs to be
333 interoperable with "signed char". Unless all frontends are revisited to
334 agree on these types, we must ignore the flag completely. */
336 /* Fortran standard define C_PTR type that is compatible with every
337 C pointer. For this reason we need to glob all pointers into one.
338 Still pointers in different address spaces are not compatible. */
339 if (POINTER_TYPE_P (type
))
340 hstate
.add_int (TYPE_ADDR_SPACE (TREE_TYPE (type
)));
342 /* For array types hash the domain bounds and the string flag. */
343 if (TREE_CODE (type
) == ARRAY_TYPE
&& TYPE_DOMAIN (type
))
345 hstate
.add_int (TYPE_STRING_FLAG (type
));
346 /* OMP lowering can introduce error_mark_node in place of
347 random local decls in types. */
348 if (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)) != error_mark_node
)
349 inchash::add_expr (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)), hstate
);
350 if (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != error_mark_node
)
351 inchash::add_expr (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)), hstate
);
354 /* Recurse for aggregates with a single element type. */
355 if (TREE_CODE (type
) == ARRAY_TYPE
356 || TREE_CODE (type
) == COMPLEX_TYPE
357 || TREE_CODE (type
) == VECTOR_TYPE
)
358 iterative_hash_canonical_type (TREE_TYPE (type
), hstate
);
360 /* Incorporate function return and argument types. */
361 if (TREE_CODE (type
) == FUNCTION_TYPE
|| TREE_CODE (type
) == METHOD_TYPE
)
366 iterative_hash_canonical_type (TREE_TYPE (type
), hstate
);
368 for (p
= TYPE_ARG_TYPES (type
), na
= 0; p
; p
= TREE_CHAIN (p
))
370 iterative_hash_canonical_type (TREE_VALUE (p
), hstate
);
377 if (RECORD_OR_UNION_TYPE_P (type
))
382 for (f
= TYPE_FIELDS (type
), nf
= 0; f
; f
= TREE_CHAIN (f
))
383 if (TREE_CODE (f
) == FIELD_DECL
)
385 iterative_hash_canonical_type (TREE_TYPE (f
), hstate
);
395 /* Returning a hash value for gimple type TYPE combined with VAL. */
398 iterative_hash_canonical_type (tree type
, inchash::hash
&hstate
)
402 /* All type variants have same TYPE_CANONICAL. */
403 type
= TYPE_MAIN_VARIANT (type
);
404 /* An already processed type. */
405 if (TYPE_CANONICAL (type
))
407 type
= TYPE_CANONICAL (type
);
408 v
= gimple_canonical_type_hash (type
);
412 /* Canonical types should not be able to form SCCs by design, this
413 recursion is just because we do not register canonical types in
414 optimal order. To avoid quadratic behavior also register the
416 v
= hash_canonical_type (type
);
417 gimple_register_canonical_type_1 (type
, v
);
422 /* Returns the hash for a canonical type P. */
425 gimple_canonical_type_hash (const void *p
)
427 num_canonical_type_hash_queries
++;
428 hashval_t
*slot
= canonical_type_hash_cache
->get ((const_tree
) p
);
429 gcc_assert (slot
!= NULL
);
435 /* Returns nonzero if P1 and P2 are equal. */
438 gimple_canonical_type_eq (const void *p1
, const void *p2
)
440 const_tree t1
= (const_tree
) p1
;
441 const_tree t2
= (const_tree
) p2
;
442 return gimple_canonical_types_compatible_p (CONST_CAST_TREE (t1
),
443 CONST_CAST_TREE (t2
));
446 /* Main worker for gimple_register_canonical_type. */
449 gimple_register_canonical_type_1 (tree t
, hashval_t hash
)
453 gcc_checking_assert (TYPE_P (t
) && !TYPE_CANONICAL (t
));
455 slot
= htab_find_slot_with_hash (gimple_canonical_types
, t
, hash
, INSERT
);
458 tree new_type
= (tree
)(*slot
);
459 gcc_checking_assert (new_type
!= t
);
460 TYPE_CANONICAL (t
) = new_type
;
464 TYPE_CANONICAL (t
) = t
;
466 /* Cache the just computed hash value. */
467 num_canonical_type_hash_entries
++;
468 bool existed_p
= canonical_type_hash_cache
->put (t
, hash
);
469 gcc_assert (!existed_p
);
473 /* Register type T in the global type table gimple_types and set
474 TYPE_CANONICAL of T accordingly.
475 This is used by LTO to merge structurally equivalent types for
476 type-based aliasing purposes across different TUs and languages.
478 ??? This merging does not exactly match how the tree.c middle-end
479 functions will assign TYPE_CANONICAL when new types are created
480 during optimization (which at least happens for pointer and array
484 gimple_register_canonical_type (tree t
)
486 if (TYPE_CANONICAL (t
) || !type_with_alias_set_p (t
))
489 /* Canonical types are same among all complete variants. */
490 if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (t
)))
491 TYPE_CANONICAL (t
) = TYPE_CANONICAL (TYPE_MAIN_VARIANT (t
));
494 gimple_register_canonical_type_1 (TYPE_MAIN_VARIANT (t
),
495 hash_canonical_type (TYPE_MAIN_VARIANT (t
)));
496 TYPE_CANONICAL (t
) = TYPE_CANONICAL (TYPE_MAIN_VARIANT (t
));
500 /* Re-compute TYPE_CANONICAL for NODE and related types. */
503 lto_register_canonical_types (tree node
, bool first_p
)
510 TYPE_CANONICAL (node
) = NULL_TREE
;
512 if (POINTER_TYPE_P (node
)
513 || TREE_CODE (node
) == COMPLEX_TYPE
514 || TREE_CODE (node
) == ARRAY_TYPE
)
515 lto_register_canonical_types (TREE_TYPE (node
), first_p
);
518 gimple_register_canonical_type (node
);
522 /* Remember trees that contains references to declarations. */
523 static GTY(()) vec
<tree
, va_gc
> *tree_with_vars
;
525 #define CHECK_VAR(tt) \
528 if ((tt) && VAR_OR_FUNCTION_DECL_P (tt) \
529 && (TREE_PUBLIC (tt) || DECL_EXTERNAL (tt))) \
533 #define CHECK_NO_VAR(tt) \
534 gcc_checking_assert (!(tt) || !VAR_OR_FUNCTION_DECL_P (tt))
536 /* Check presence of pointers to decls in fields of a tree_typed T. */
539 mentions_vars_p_typed (tree t
)
541 CHECK_NO_VAR (TREE_TYPE (t
));
545 /* Check presence of pointers to decls in fields of a tree_common T. */
548 mentions_vars_p_common (tree t
)
550 if (mentions_vars_p_typed (t
))
552 CHECK_NO_VAR (TREE_CHAIN (t
));
556 /* Check presence of pointers to decls in fields of a decl_minimal T. */
559 mentions_vars_p_decl_minimal (tree t
)
561 if (mentions_vars_p_common (t
))
563 CHECK_NO_VAR (DECL_NAME (t
));
564 CHECK_VAR (DECL_CONTEXT (t
));
568 /* Check presence of pointers to decls in fields of a decl_common T. */
571 mentions_vars_p_decl_common (tree t
)
573 if (mentions_vars_p_decl_minimal (t
))
575 CHECK_VAR (DECL_SIZE (t
));
576 CHECK_VAR (DECL_SIZE_UNIT (t
));
577 CHECK_VAR (DECL_INITIAL (t
));
578 CHECK_NO_VAR (DECL_ATTRIBUTES (t
));
579 CHECK_VAR (DECL_ABSTRACT_ORIGIN (t
));
583 /* Check presence of pointers to decls in fields of a decl_with_vis T. */
586 mentions_vars_p_decl_with_vis (tree t
)
588 if (mentions_vars_p_decl_common (t
))
591 /* Accessor macro has side-effects, use field-name here. */
592 CHECK_NO_VAR (t
->decl_with_vis
.assembler_name
);
596 /* Check presence of pointers to decls in fields of a decl_non_common T. */
599 mentions_vars_p_decl_non_common (tree t
)
601 if (mentions_vars_p_decl_with_vis (t
))
603 CHECK_NO_VAR (DECL_RESULT_FLD (t
));
607 /* Check presence of pointers to decls in fields of a decl_non_common T. */
610 mentions_vars_p_function (tree t
)
612 if (mentions_vars_p_decl_non_common (t
))
614 CHECK_NO_VAR (DECL_ARGUMENTS (t
));
615 CHECK_NO_VAR (DECL_VINDEX (t
));
616 CHECK_VAR (DECL_FUNCTION_PERSONALITY (t
));
620 /* Check presence of pointers to decls in fields of a field_decl T. */
623 mentions_vars_p_field_decl (tree t
)
625 if (mentions_vars_p_decl_common (t
))
627 CHECK_VAR (DECL_FIELD_OFFSET (t
));
628 CHECK_NO_VAR (DECL_BIT_FIELD_TYPE (t
));
629 CHECK_NO_VAR (DECL_QUALIFIER (t
));
630 CHECK_NO_VAR (DECL_FIELD_BIT_OFFSET (t
));
631 CHECK_NO_VAR (DECL_FCONTEXT (t
));
635 /* Check presence of pointers to decls in fields of a type T. */
638 mentions_vars_p_type (tree t
)
640 if (mentions_vars_p_common (t
))
642 CHECK_NO_VAR (TYPE_CACHED_VALUES (t
));
643 CHECK_VAR (TYPE_SIZE (t
));
644 CHECK_VAR (TYPE_SIZE_UNIT (t
));
645 CHECK_NO_VAR (TYPE_ATTRIBUTES (t
));
646 CHECK_NO_VAR (TYPE_NAME (t
));
648 CHECK_VAR (TYPE_MINVAL (t
));
649 CHECK_VAR (TYPE_MAXVAL (t
));
651 /* Accessor is for derived node types only. */
652 CHECK_NO_VAR (t
->type_non_common
.binfo
);
654 CHECK_VAR (TYPE_CONTEXT (t
));
655 CHECK_NO_VAR (TYPE_CANONICAL (t
));
656 CHECK_NO_VAR (TYPE_MAIN_VARIANT (t
));
657 CHECK_NO_VAR (TYPE_NEXT_VARIANT (t
));
661 /* Check presence of pointers to decls in fields of a BINFO T. */
664 mentions_vars_p_binfo (tree t
)
666 unsigned HOST_WIDE_INT i
, n
;
668 if (mentions_vars_p_common (t
))
670 CHECK_VAR (BINFO_VTABLE (t
));
671 CHECK_NO_VAR (BINFO_OFFSET (t
));
672 CHECK_NO_VAR (BINFO_VIRTUALS (t
));
673 CHECK_NO_VAR (BINFO_VPTR_FIELD (t
));
674 n
= vec_safe_length (BINFO_BASE_ACCESSES (t
));
675 for (i
= 0; i
< n
; i
++)
676 CHECK_NO_VAR (BINFO_BASE_ACCESS (t
, i
));
677 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
678 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
679 n
= BINFO_N_BASE_BINFOS (t
);
680 for (i
= 0; i
< n
; i
++)
681 CHECK_NO_VAR (BINFO_BASE_BINFO (t
, i
));
685 /* Check presence of pointers to decls in fields of a CONSTRUCTOR T. */
688 mentions_vars_p_constructor (tree t
)
690 unsigned HOST_WIDE_INT idx
;
693 if (mentions_vars_p_typed (t
))
696 for (idx
= 0; vec_safe_iterate (CONSTRUCTOR_ELTS (t
), idx
, &ce
); idx
++)
698 CHECK_NO_VAR (ce
->index
);
699 CHECK_VAR (ce
->value
);
704 /* Check presence of pointers to decls in fields of an expression tree T. */
707 mentions_vars_p_expr (tree t
)
710 if (mentions_vars_p_typed (t
))
712 for (i
= TREE_OPERAND_LENGTH (t
) - 1; i
>= 0; --i
)
713 CHECK_VAR (TREE_OPERAND (t
, i
));
717 /* Check presence of pointers to decls in fields of an OMP_CLAUSE T. */
720 mentions_vars_p_omp_clause (tree t
)
723 if (mentions_vars_p_common (t
))
725 for (i
= omp_clause_num_ops
[OMP_CLAUSE_CODE (t
)] - 1; i
>= 0; --i
)
726 CHECK_VAR (OMP_CLAUSE_OPERAND (t
, i
));
730 /* Check presence of pointers to decls that needs later fixup in T. */
733 mentions_vars_p (tree t
)
735 switch (TREE_CODE (t
))
737 case IDENTIFIER_NODE
:
741 CHECK_VAR (TREE_VALUE (t
));
742 CHECK_VAR (TREE_PURPOSE (t
));
743 CHECK_NO_VAR (TREE_CHAIN (t
));
747 return mentions_vars_p_field_decl (t
);
756 return mentions_vars_p_decl_common (t
);
759 return mentions_vars_p_decl_with_vis (t
);
762 return mentions_vars_p_decl_non_common (t
);
765 return mentions_vars_p_function (t
);
768 return mentions_vars_p_binfo (t
);
770 case PLACEHOLDER_EXPR
:
771 return mentions_vars_p_common (t
);
774 case TRANSLATION_UNIT_DECL
:
775 case OPTIMIZATION_NODE
:
776 case TARGET_OPTION_NODE
:
780 return mentions_vars_p_constructor (t
);
783 return mentions_vars_p_omp_clause (t
);
788 if (mentions_vars_p_type (t
))
793 if (mentions_vars_p_expr (t
))
796 else if (CONSTANT_CLASS_P (t
))
797 CHECK_NO_VAR (TREE_TYPE (t
));
805 /* Return the resolution for the decl with index INDEX from DATA_IN. */
807 static enum ld_plugin_symbol_resolution
808 get_resolution (struct data_in
*data_in
, unsigned index
)
810 if (data_in
->globals_resolution
.exists ())
812 ld_plugin_symbol_resolution_t ret
;
813 /* We can have references to not emitted functions in
814 DECL_FUNCTION_PERSONALITY at least. So we can and have
815 to indeed return LDPR_UNKNOWN in some cases. */
816 if (data_in
->globals_resolution
.length () <= index
)
818 ret
= data_in
->globals_resolution
[index
];
822 /* Delay resolution finding until decl merging. */
826 /* We need to record resolutions until symbol table is read. */
828 register_resolution (struct lto_file_decl_data
*file_data
, tree decl
,
829 enum ld_plugin_symbol_resolution resolution
)
831 if (resolution
== LDPR_UNKNOWN
)
833 if (!file_data
->resolution_map
)
834 file_data
->resolution_map
835 = new hash_map
<tree
, ld_plugin_symbol_resolution
>;
836 file_data
->resolution_map
->put (decl
, resolution
);
839 /* Register DECL with the global symbol table and change its
840 name if necessary to avoid name clashes for static globals across
844 lto_register_var_decl_in_symtab (struct data_in
*data_in
, tree decl
,
849 /* Variable has file scope, not local. */
850 if (!TREE_PUBLIC (decl
)
851 && !((context
= decl_function_context (decl
))
852 && auto_var_in_fn_p (decl
, context
)))
853 rest_of_decl_compilation (decl
, 1, 0);
855 /* If this variable has already been declared, queue the
856 declaration for merging. */
857 if (TREE_PUBLIC (decl
))
858 register_resolution (data_in
->file_data
,
859 decl
, get_resolution (data_in
, ix
));
863 /* Register DECL with the global symbol table and change its
864 name if necessary to avoid name clashes for static globals across
865 different files. DATA_IN contains descriptors and tables for the
869 lto_register_function_decl_in_symtab (struct data_in
*data_in
, tree decl
,
872 /* If this variable has already been declared, queue the
873 declaration for merging. */
874 if (TREE_PUBLIC (decl
) && !DECL_ABSTRACT_P (decl
))
875 register_resolution (data_in
->file_data
,
876 decl
, get_resolution (data_in
, ix
));
880 /* For the type T re-materialize it in the type variant list and
881 the pointer/reference-to chains. */
884 lto_fixup_prevailing_type (tree t
)
886 /* The following re-creates proper variant lists while fixing up
887 the variant leaders. We do not stream TYPE_NEXT_VARIANT so the
888 variant list state before fixup is broken. */
890 /* If we are not our own variant leader link us into our new leaders
892 if (TYPE_MAIN_VARIANT (t
) != t
)
894 tree mv
= TYPE_MAIN_VARIANT (t
);
895 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (mv
);
896 TYPE_NEXT_VARIANT (mv
) = t
;
899 /* The following reconstructs the pointer chains
900 of the new pointed-to type if we are a main variant. We do
901 not stream those so they are broken before fixup. */
902 if (TREE_CODE (t
) == POINTER_TYPE
903 && TYPE_MAIN_VARIANT (t
) == t
)
905 TYPE_NEXT_PTR_TO (t
) = TYPE_POINTER_TO (TREE_TYPE (t
));
906 TYPE_POINTER_TO (TREE_TYPE (t
)) = t
;
908 else if (TREE_CODE (t
) == REFERENCE_TYPE
909 && TYPE_MAIN_VARIANT (t
) == t
)
911 TYPE_NEXT_REF_TO (t
) = TYPE_REFERENCE_TO (TREE_TYPE (t
));
912 TYPE_REFERENCE_TO (TREE_TYPE (t
)) = t
;
917 /* We keep prevailing tree SCCs in a hashtable with manual collision
918 handling (in case all hashes compare the same) and keep the colliding
919 entries in the tree_scc->next chain. */
924 /* Hash of the whole SCC. */
926 /* Number of trees in the SCC. */
928 /* Number of possible entries into the SCC (tree nodes [0..entry_len-1]
929 which share the same individual tree hash). */
931 /* The members of the SCC.
932 We only need to remember the first entry node candidate for prevailing
933 SCCs (but of course have access to all entries for SCCs we are
935 ??? For prevailing SCCs we really only need hash and the first
936 entry candidate, but that's too awkward to implement. */
940 struct tree_scc_hasher
: nofree_ptr_hash
<tree_scc
>
942 static inline hashval_t
hash (const tree_scc
*);
943 static inline bool equal (const tree_scc
*, const tree_scc
*);
947 tree_scc_hasher::hash (const tree_scc
*scc
)
953 tree_scc_hasher::equal (const tree_scc
*scc1
, const tree_scc
*scc2
)
955 if (scc1
->hash
!= scc2
->hash
956 || scc1
->len
!= scc2
->len
957 || scc1
->entry_len
!= scc2
->entry_len
)
962 static hash_table
<tree_scc_hasher
> *tree_scc_hash
;
963 static struct obstack tree_scc_hash_obstack
;
965 static unsigned long num_merged_types
;
966 static unsigned long num_prevailing_types
;
967 static unsigned long num_type_scc_trees
;
968 static unsigned long total_scc_size
;
969 static unsigned long num_sccs_read
;
970 static unsigned long total_scc_size_merged
;
971 static unsigned long num_sccs_merged
;
972 static unsigned long num_scc_compares
;
973 static unsigned long num_scc_compare_collisions
;
976 /* Compare the two entries T1 and T2 of two SCCs that are possibly equal,
977 recursing through in-SCC tree edges. Returns true if the SCCs entered
978 through T1 and T2 are equal and fills in *MAP with the pairs of
979 SCC entries we visited, starting with (*MAP)[0] = T1 and (*MAP)[1] = T2. */
982 compare_tree_sccs_1 (tree t1
, tree t2
, tree
**map
)
986 /* Mark already visited nodes. */
987 TREE_ASM_WRITTEN (t2
) = 1;
989 /* Push the pair onto map. */
994 /* Compare value-fields. */
995 #define compare_values(X) \
997 if (X(t1) != X(t2)) \
1001 compare_values (TREE_CODE
);
1002 code
= TREE_CODE (t1
);
1006 compare_values (TREE_SIDE_EFFECTS
);
1007 compare_values (TREE_CONSTANT
);
1008 compare_values (TREE_READONLY
);
1009 compare_values (TREE_PUBLIC
);
1011 compare_values (TREE_ADDRESSABLE
);
1012 compare_values (TREE_THIS_VOLATILE
);
1014 compare_values (DECL_UNSIGNED
);
1015 else if (TYPE_P (t1
))
1016 compare_values (TYPE_UNSIGNED
);
1018 compare_values (TYPE_ARTIFICIAL
);
1020 compare_values (TREE_NO_WARNING
);
1021 compare_values (TREE_NOTHROW
);
1022 compare_values (TREE_STATIC
);
1023 if (code
!= TREE_BINFO
)
1024 compare_values (TREE_PRIVATE
);
1025 compare_values (TREE_PROTECTED
);
1026 compare_values (TREE_DEPRECATED
);
1029 compare_values (TYPE_SATURATING
);
1030 compare_values (TYPE_ADDR_SPACE
);
1032 else if (code
== SSA_NAME
)
1033 compare_values (SSA_NAME_IS_DEFAULT_DEF
);
1035 if (CODE_CONTAINS_STRUCT (code
, TS_INT_CST
))
1037 if (!wi::eq_p (t1
, t2
))
1041 if (CODE_CONTAINS_STRUCT (code
, TS_REAL_CST
))
1043 /* ??? No suitable compare routine available. */
1044 REAL_VALUE_TYPE r1
= TREE_REAL_CST (t1
);
1045 REAL_VALUE_TYPE r2
= TREE_REAL_CST (t2
);
1047 || r1
.decimal
!= r2
.decimal
1048 || r1
.sign
!= r2
.sign
1049 || r1
.signalling
!= r2
.signalling
1050 || r1
.canonical
!= r2
.canonical
1051 || r1
.uexp
!= r2
.uexp
)
1053 for (unsigned i
= 0; i
< SIGSZ
; ++i
)
1054 if (r1
.sig
[i
] != r2
.sig
[i
])
1058 if (CODE_CONTAINS_STRUCT (code
, TS_FIXED_CST
))
1059 if (!fixed_compare (EQ_EXPR
,
1060 TREE_FIXED_CST_PTR (t1
), TREE_FIXED_CST_PTR (t2
)))
1064 /* We don't want to compare locations, so there is nothing do compare
1065 for TS_DECL_MINIMAL. */
1067 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1069 compare_values (DECL_MODE
);
1070 compare_values (DECL_NONLOCAL
);
1071 compare_values (DECL_VIRTUAL_P
);
1072 compare_values (DECL_IGNORED_P
);
1073 compare_values (DECL_ABSTRACT_P
);
1074 compare_values (DECL_ARTIFICIAL
);
1075 compare_values (DECL_USER_ALIGN
);
1076 compare_values (DECL_PRESERVE_P
);
1077 compare_values (DECL_EXTERNAL
);
1078 compare_values (DECL_GIMPLE_REG_P
);
1079 compare_values (DECL_ALIGN
);
1080 if (code
== LABEL_DECL
)
1082 compare_values (EH_LANDING_PAD_NR
);
1083 compare_values (LABEL_DECL_UID
);
1085 else if (code
== FIELD_DECL
)
1087 compare_values (DECL_PACKED
);
1088 compare_values (DECL_NONADDRESSABLE_P
);
1089 compare_values (DECL_OFFSET_ALIGN
);
1091 else if (code
== VAR_DECL
)
1093 compare_values (DECL_HAS_DEBUG_EXPR_P
);
1094 compare_values (DECL_NONLOCAL_FRAME
);
1096 if (code
== RESULT_DECL
1097 || code
== PARM_DECL
1098 || code
== VAR_DECL
)
1100 compare_values (DECL_BY_REFERENCE
);
1101 if (code
== VAR_DECL
1102 || code
== PARM_DECL
)
1103 compare_values (DECL_HAS_VALUE_EXPR_P
);
1107 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WRTL
))
1108 compare_values (DECL_REGISTER
);
1110 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1112 compare_values (DECL_COMMON
);
1113 compare_values (DECL_DLLIMPORT_P
);
1114 compare_values (DECL_WEAK
);
1115 compare_values (DECL_SEEN_IN_BIND_EXPR_P
);
1116 compare_values (DECL_COMDAT
);
1117 compare_values (DECL_VISIBILITY
);
1118 compare_values (DECL_VISIBILITY_SPECIFIED
);
1119 if (code
== VAR_DECL
)
1121 compare_values (DECL_HARD_REGISTER
);
1122 /* DECL_IN_TEXT_SECTION is set during final asm output only. */
1123 compare_values (DECL_IN_CONSTANT_POOL
);
1127 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1129 compare_values (DECL_BUILT_IN_CLASS
);
1130 compare_values (DECL_STATIC_CONSTRUCTOR
);
1131 compare_values (DECL_STATIC_DESTRUCTOR
);
1132 compare_values (DECL_UNINLINABLE
);
1133 compare_values (DECL_POSSIBLY_INLINED
);
1134 compare_values (DECL_IS_NOVOPS
);
1135 compare_values (DECL_IS_RETURNS_TWICE
);
1136 compare_values (DECL_IS_MALLOC
);
1137 compare_values (DECL_IS_OPERATOR_NEW
);
1138 compare_values (DECL_DECLARED_INLINE_P
);
1139 compare_values (DECL_STATIC_CHAIN
);
1140 compare_values (DECL_NO_INLINE_WARNING_P
);
1141 compare_values (DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT
);
1142 compare_values (DECL_NO_LIMIT_STACK
);
1143 compare_values (DECL_DISREGARD_INLINE_LIMITS
);
1144 compare_values (DECL_PURE_P
);
1145 compare_values (DECL_LOOPING_CONST_OR_PURE_P
);
1146 compare_values (DECL_FINAL_P
);
1147 compare_values (DECL_CXX_CONSTRUCTOR_P
);
1148 compare_values (DECL_CXX_DESTRUCTOR_P
);
1149 if (DECL_BUILT_IN_CLASS (t1
) != NOT_BUILT_IN
)
1150 compare_values (DECL_FUNCTION_CODE
);
1153 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
1155 compare_values (TYPE_MODE
);
1156 compare_values (TYPE_STRING_FLAG
);
1157 compare_values (TYPE_NEEDS_CONSTRUCTING
);
1158 if (RECORD_OR_UNION_TYPE_P (t1
))
1160 compare_values (TYPE_TRANSPARENT_AGGR
);
1161 compare_values (TYPE_FINAL_P
);
1163 else if (code
== ARRAY_TYPE
)
1164 compare_values (TYPE_NONALIASED_COMPONENT
);
1165 compare_values (TYPE_PACKED
);
1166 compare_values (TYPE_RESTRICT
);
1167 compare_values (TYPE_USER_ALIGN
);
1168 compare_values (TYPE_READONLY
);
1169 compare_values (TYPE_PRECISION
);
1170 compare_values (TYPE_ALIGN
);
1171 compare_values (TYPE_ALIAS_SET
);
1174 /* We don't want to compare locations, so there is nothing do compare
1177 /* BLOCKs are function local and we don't merge anything there, so
1178 simply refuse to merge. */
1179 if (CODE_CONTAINS_STRUCT (code
, TS_BLOCK
))
1182 if (CODE_CONTAINS_STRUCT (code
, TS_TRANSLATION_UNIT_DECL
))
1183 if (strcmp (TRANSLATION_UNIT_LANGUAGE (t1
),
1184 TRANSLATION_UNIT_LANGUAGE (t2
)) != 0)
1187 if (CODE_CONTAINS_STRUCT (code
, TS_TARGET_OPTION
))
1188 if (!cl_target_option_eq (TREE_TARGET_OPTION (t1
), TREE_TARGET_OPTION (t2
)))
1191 if (CODE_CONTAINS_STRUCT (code
, TS_OPTIMIZATION
))
1192 if (memcmp (TREE_OPTIMIZATION (t1
), TREE_OPTIMIZATION (t2
),
1193 sizeof (struct cl_optimization
)) != 0)
1196 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1197 if (vec_safe_length (BINFO_BASE_ACCESSES (t1
))
1198 != vec_safe_length (BINFO_BASE_ACCESSES (t2
)))
1201 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1202 compare_values (CONSTRUCTOR_NELTS
);
1204 if (CODE_CONTAINS_STRUCT (code
, TS_IDENTIFIER
))
1205 if (IDENTIFIER_LENGTH (t1
) != IDENTIFIER_LENGTH (t2
)
1206 || memcmp (IDENTIFIER_POINTER (t1
), IDENTIFIER_POINTER (t2
),
1207 IDENTIFIER_LENGTH (t1
)) != 0)
1210 if (CODE_CONTAINS_STRUCT (code
, TS_STRING
))
1211 if (TREE_STRING_LENGTH (t1
) != TREE_STRING_LENGTH (t2
)
1212 || memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
1213 TREE_STRING_LENGTH (t1
)) != 0)
1216 if (code
== OMP_CLAUSE
)
1218 compare_values (OMP_CLAUSE_CODE
);
1219 switch (OMP_CLAUSE_CODE (t1
))
1221 case OMP_CLAUSE_DEFAULT
:
1222 compare_values (OMP_CLAUSE_DEFAULT_KIND
);
1224 case OMP_CLAUSE_SCHEDULE
:
1225 compare_values (OMP_CLAUSE_SCHEDULE_KIND
);
1227 case OMP_CLAUSE_DEPEND
:
1228 compare_values (OMP_CLAUSE_DEPEND_KIND
);
1230 case OMP_CLAUSE_MAP
:
1231 compare_values (OMP_CLAUSE_MAP_KIND
);
1233 case OMP_CLAUSE_PROC_BIND
:
1234 compare_values (OMP_CLAUSE_PROC_BIND_KIND
);
1236 case OMP_CLAUSE_REDUCTION
:
1237 compare_values (OMP_CLAUSE_REDUCTION_CODE
);
1238 compare_values (OMP_CLAUSE_REDUCTION_GIMPLE_INIT
);
1239 compare_values (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE
);
1246 #undef compare_values
1249 /* Compare pointer fields. */
1251 /* Recurse. Search & Replaced from DFS_write_tree_body.
1252 Folding the early checks into the compare_tree_edges recursion
1253 macro makes debugging way quicker as you are able to break on
1254 compare_tree_sccs_1 and simply finish until a call returns false
1255 to spot the SCC members with the difference. */
1256 #define compare_tree_edges(E1, E2) \
1258 tree t1_ = (E1), t2_ = (E2); \
1261 || !TREE_VISITED (t2_) \
1262 || (!TREE_ASM_WRITTEN (t2_) \
1263 && !compare_tree_sccs_1 (t1_, t2_, map)))) \
1265 /* Only non-NULL trees outside of the SCC may compare equal. */ \
1266 gcc_checking_assert (t1_ != t2_ || (!t2_ || !TREE_VISITED (t2_))); \
1269 if (CODE_CONTAINS_STRUCT (code
, TS_TYPED
))
1271 if (code
!= IDENTIFIER_NODE
)
1272 compare_tree_edges (TREE_TYPE (t1
), TREE_TYPE (t2
));
1275 if (CODE_CONTAINS_STRUCT (code
, TS_VECTOR
))
1278 /* Note that the number of elements for EXPR has already been emitted
1279 in EXPR's header (see streamer_write_tree_header). */
1280 for (i
= 0; i
< VECTOR_CST_NELTS (t1
); ++i
)
1281 compare_tree_edges (VECTOR_CST_ELT (t1
, i
), VECTOR_CST_ELT (t2
, i
));
1284 if (CODE_CONTAINS_STRUCT (code
, TS_COMPLEX
))
1286 compare_tree_edges (TREE_REALPART (t1
), TREE_REALPART (t2
));
1287 compare_tree_edges (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
));
1290 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_MINIMAL
))
1292 compare_tree_edges (DECL_NAME (t1
), DECL_NAME (t2
));
1293 /* ??? Global decls from different TUs have non-matching
1294 TRANSLATION_UNIT_DECLs. Only consider a small set of
1295 decls equivalent, we should not end up merging others. */
1296 if ((code
== TYPE_DECL
1297 || code
== NAMESPACE_DECL
1298 || code
== IMPORTED_DECL
1299 || code
== CONST_DECL
1300 || (VAR_OR_FUNCTION_DECL_P (t1
)
1301 && (TREE_PUBLIC (t1
) || DECL_EXTERNAL (t1
))))
1302 && DECL_FILE_SCOPE_P (t1
) && DECL_FILE_SCOPE_P (t2
))
1305 compare_tree_edges (DECL_CONTEXT (t1
), DECL_CONTEXT (t2
));
1308 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
1310 compare_tree_edges (DECL_SIZE (t1
), DECL_SIZE (t2
));
1311 compare_tree_edges (DECL_SIZE_UNIT (t1
), DECL_SIZE_UNIT (t2
));
1312 compare_tree_edges (DECL_ATTRIBUTES (t1
), DECL_ATTRIBUTES (t2
));
1313 if ((code
== VAR_DECL
1314 || code
== PARM_DECL
)
1315 && DECL_HAS_VALUE_EXPR_P (t1
))
1316 compare_tree_edges (DECL_VALUE_EXPR (t1
), DECL_VALUE_EXPR (t2
));
1317 if (code
== VAR_DECL
1318 && DECL_HAS_DEBUG_EXPR_P (t1
))
1319 compare_tree_edges (DECL_DEBUG_EXPR (t1
), DECL_DEBUG_EXPR (t2
));
1320 /* LTO specific edges. */
1321 if (code
!= FUNCTION_DECL
1322 && code
!= TRANSLATION_UNIT_DECL
)
1323 compare_tree_edges (DECL_INITIAL (t1
), DECL_INITIAL (t2
));
1326 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
1328 if (code
== FUNCTION_DECL
)
1331 for (a1
= DECL_ARGUMENTS (t1
), a2
= DECL_ARGUMENTS (t2
);
1333 a1
= TREE_CHAIN (a1
), a2
= TREE_CHAIN (a2
))
1334 compare_tree_edges (a1
, a2
);
1335 compare_tree_edges (DECL_RESULT (t1
), DECL_RESULT (t2
));
1337 else if (code
== TYPE_DECL
)
1338 compare_tree_edges (DECL_ORIGINAL_TYPE (t1
), DECL_ORIGINAL_TYPE (t2
));
1341 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
1343 /* Make sure we don't inadvertently set the assembler name. */
1344 if (DECL_ASSEMBLER_NAME_SET_P (t1
))
1345 compare_tree_edges (DECL_ASSEMBLER_NAME (t1
),
1346 DECL_ASSEMBLER_NAME (t2
));
1349 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
1351 compare_tree_edges (DECL_FIELD_OFFSET (t1
), DECL_FIELD_OFFSET (t2
));
1352 compare_tree_edges (DECL_BIT_FIELD_TYPE (t1
), DECL_BIT_FIELD_TYPE (t2
));
1353 compare_tree_edges (DECL_BIT_FIELD_REPRESENTATIVE (t1
),
1354 DECL_BIT_FIELD_REPRESENTATIVE (t2
));
1355 compare_tree_edges (DECL_FIELD_BIT_OFFSET (t1
),
1356 DECL_FIELD_BIT_OFFSET (t2
));
1357 compare_tree_edges (DECL_FCONTEXT (t1
), DECL_FCONTEXT (t2
));
1360 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
1362 compare_tree_edges (DECL_FUNCTION_PERSONALITY (t1
),
1363 DECL_FUNCTION_PERSONALITY (t2
));
1364 compare_tree_edges (DECL_VINDEX (t1
), DECL_VINDEX (t2
));
1365 compare_tree_edges (DECL_FUNCTION_SPECIFIC_TARGET (t1
),
1366 DECL_FUNCTION_SPECIFIC_TARGET (t2
));
1367 compare_tree_edges (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t1
),
1368 DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t2
));
1371 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_COMMON
))
1373 compare_tree_edges (TYPE_SIZE (t1
), TYPE_SIZE (t2
));
1374 compare_tree_edges (TYPE_SIZE_UNIT (t1
), TYPE_SIZE_UNIT (t2
));
1375 compare_tree_edges (TYPE_ATTRIBUTES (t1
), TYPE_ATTRIBUTES (t2
));
1376 compare_tree_edges (TYPE_NAME (t1
), TYPE_NAME (t2
));
1377 /* Do not compare TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be
1378 reconstructed during fixup. */
1379 /* Do not compare TYPE_NEXT_VARIANT, we reconstruct the variant lists
1381 compare_tree_edges (TYPE_MAIN_VARIANT (t1
), TYPE_MAIN_VARIANT (t2
));
1382 /* ??? Global types from different TUs have non-matching
1383 TRANSLATION_UNIT_DECLs. Still merge them if they are otherwise
1385 if (TYPE_FILE_SCOPE_P (t1
) && TYPE_FILE_SCOPE_P (t2
))
1388 compare_tree_edges (TYPE_CONTEXT (t1
), TYPE_CONTEXT (t2
));
1389 /* TYPE_CANONICAL is re-computed during type merging, so do not
1391 compare_tree_edges (TYPE_STUB_DECL (t1
), TYPE_STUB_DECL (t2
));
1394 if (CODE_CONTAINS_STRUCT (code
, TS_TYPE_NON_COMMON
))
1396 if (code
== ENUMERAL_TYPE
)
1397 compare_tree_edges (TYPE_VALUES (t1
), TYPE_VALUES (t2
));
1398 else if (code
== ARRAY_TYPE
)
1399 compare_tree_edges (TYPE_DOMAIN (t1
), TYPE_DOMAIN (t2
));
1400 else if (RECORD_OR_UNION_TYPE_P (t1
))
1403 for (f1
= TYPE_FIELDS (t1
), f2
= TYPE_FIELDS (t2
);
1405 f1
= TREE_CHAIN (f1
), f2
= TREE_CHAIN (f2
))
1406 compare_tree_edges (f1
, f2
);
1407 compare_tree_edges (TYPE_BINFO (t1
), TYPE_BINFO (t2
));
1409 else if (code
== FUNCTION_TYPE
1410 || code
== METHOD_TYPE
)
1411 compare_tree_edges (TYPE_ARG_TYPES (t1
), TYPE_ARG_TYPES (t2
));
1412 if (!POINTER_TYPE_P (t1
))
1413 compare_tree_edges (TYPE_MINVAL (t1
), TYPE_MINVAL (t2
));
1414 compare_tree_edges (TYPE_MAXVAL (t1
), TYPE_MAXVAL (t2
));
1417 if (CODE_CONTAINS_STRUCT (code
, TS_LIST
))
1419 compare_tree_edges (TREE_PURPOSE (t1
), TREE_PURPOSE (t2
));
1420 compare_tree_edges (TREE_VALUE (t1
), TREE_VALUE (t2
));
1421 compare_tree_edges (TREE_CHAIN (t1
), TREE_CHAIN (t2
));
1424 if (CODE_CONTAINS_STRUCT (code
, TS_VEC
))
1425 for (int i
= 0; i
< TREE_VEC_LENGTH (t1
); i
++)
1426 compare_tree_edges (TREE_VEC_ELT (t1
, i
), TREE_VEC_ELT (t2
, i
));
1428 if (CODE_CONTAINS_STRUCT (code
, TS_EXP
))
1430 for (int i
= 0; i
< TREE_OPERAND_LENGTH (t1
); i
++)
1431 compare_tree_edges (TREE_OPERAND (t1
, i
),
1432 TREE_OPERAND (t2
, i
));
1434 /* BLOCKs are function local and we don't merge anything there. */
1435 if (TREE_BLOCK (t1
) || TREE_BLOCK (t2
))
1439 if (CODE_CONTAINS_STRUCT (code
, TS_BINFO
))
1443 /* Lengths have already been compared above. */
1444 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (t1
), i
, t
)
1445 compare_tree_edges (t
, BINFO_BASE_BINFO (t2
, i
));
1446 FOR_EACH_VEC_SAFE_ELT (BINFO_BASE_ACCESSES (t1
), i
, t
)
1447 compare_tree_edges (t
, BINFO_BASE_ACCESS (t2
, i
));
1448 compare_tree_edges (BINFO_OFFSET (t1
), BINFO_OFFSET (t2
));
1449 compare_tree_edges (BINFO_VTABLE (t1
), BINFO_VTABLE (t2
));
1450 compare_tree_edges (BINFO_VPTR_FIELD (t1
), BINFO_VPTR_FIELD (t2
));
1451 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX
1452 and BINFO_VPTR_INDEX; these are used by C++ FE only. */
1455 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1459 /* Lengths have already been compared above. */
1460 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t1
), i
, index
, value
)
1462 compare_tree_edges (index
, CONSTRUCTOR_ELT (t2
, i
)->index
);
1463 compare_tree_edges (value
, CONSTRUCTOR_ELT (t2
, i
)->value
);
1467 if (code
== OMP_CLAUSE
)
1471 for (i
= 0; i
< omp_clause_num_ops
[OMP_CLAUSE_CODE (t1
)]; i
++)
1472 compare_tree_edges (OMP_CLAUSE_OPERAND (t1
, i
),
1473 OMP_CLAUSE_OPERAND (t2
, i
));
1474 compare_tree_edges (OMP_CLAUSE_CHAIN (t1
), OMP_CLAUSE_CHAIN (t2
));
1477 #undef compare_tree_edges
1482 /* Compare the tree scc SCC to the prevailing candidate PSCC, filling
1483 out MAP if they are equal. */
1486 compare_tree_sccs (tree_scc
*pscc
, tree_scc
*scc
,
1489 /* Assume SCC entry hashes are sorted after their cardinality. Which
1490 means we can simply take the first n-tuple of equal hashes
1491 (which is recorded as entry_len) and do n SCC entry candidate
1493 for (unsigned i
= 0; i
< pscc
->entry_len
; ++i
)
1496 num_scc_compare_collisions
++;
1497 if (compare_tree_sccs_1 (pscc
->entries
[0], scc
->entries
[i
], &mapp
))
1499 /* Equal - no need to reset TREE_VISITED or TREE_ASM_WRITTEN
1500 on the scc as all trees will be freed. */
1503 /* Reset TREE_ASM_WRITTEN on scc for the next compare or in case
1504 the SCC prevails. */
1505 for (unsigned j
= 0; j
< scc
->len
; ++j
)
1506 TREE_ASM_WRITTEN (scc
->entries
[j
]) = 0;
1512 /* QSort sort function to sort a map of two pointers after the 2nd
1516 cmp_tree (const void *p1_
, const void *p2_
)
1518 tree
*p1
= (tree
*)(const_cast<void *>(p1_
));
1519 tree
*p2
= (tree
*)(const_cast<void *>(p2_
));
1522 return ((uintptr_t)p1
[1] < (uintptr_t)p2
[1]) ? -1 : 1;
1525 /* Try to unify the SCC with nodes FROM to FROM + LEN in CACHE and
1526 hash value SCC_HASH with an already recorded SCC. Return true if
1527 that was successful, otherwise return false. */
1530 unify_scc (struct data_in
*data_in
, unsigned from
,
1531 unsigned len
, unsigned scc_entry_len
, hashval_t scc_hash
)
1533 bool unified_p
= false;
1534 struct streamer_tree_cache_d
*cache
= data_in
->reader_cache
;
1536 = (tree_scc
*) alloca (sizeof (tree_scc
) + (len
- 1) * sizeof (tree
));
1538 scc
->hash
= scc_hash
;
1540 scc
->entry_len
= scc_entry_len
;
1541 for (unsigned i
= 0; i
< len
; ++i
)
1543 tree t
= streamer_tree_cache_get_tree (cache
, from
+ i
);
1544 scc
->entries
[i
] = t
;
1545 /* Do not merge SCCs with local entities inside them. Also do
1546 not merge TRANSLATION_UNIT_DECLs. */
1547 if (TREE_CODE (t
) == TRANSLATION_UNIT_DECL
1548 || (VAR_OR_FUNCTION_DECL_P (t
)
1549 && !(TREE_PUBLIC (t
) || DECL_EXTERNAL (t
)))
1550 || TREE_CODE (t
) == LABEL_DECL
)
1552 /* Avoid doing any work for these cases and do not worry to
1553 record the SCCs for further merging. */
1558 /* Look for the list of candidate SCCs to compare against. */
1560 slot
= tree_scc_hash
->find_slot_with_hash (scc
, scc_hash
, INSERT
);
1563 /* Try unifying against each candidate. */
1566 /* Set TREE_VISITED on the scc so we can easily identify tree nodes
1567 outside of the scc when following tree edges. Make sure
1568 that TREE_ASM_WRITTEN is unset so we can use it as 2nd bit
1569 to track whether we visited the SCC member during the compare.
1570 We cannot use TREE_VISITED on the pscc members as the extended
1571 scc and pscc can overlap. */
1572 for (unsigned i
= 0; i
< scc
->len
; ++i
)
1574 TREE_VISITED (scc
->entries
[i
]) = 1;
1575 gcc_checking_assert (!TREE_ASM_WRITTEN (scc
->entries
[i
]));
1578 tree
*map
= XALLOCAVEC (tree
, 2 * len
);
1579 for (tree_scc
*pscc
= *slot
; pscc
; pscc
= pscc
->next
)
1581 if (!compare_tree_sccs (pscc
, scc
, map
))
1584 /* Found an equal SCC. */
1586 num_scc_compare_collisions
--;
1588 total_scc_size_merged
+= len
;
1590 #ifdef ENABLE_CHECKING
1591 for (unsigned i
= 0; i
< len
; ++i
)
1593 tree t
= map
[2*i
+1];
1594 enum tree_code code
= TREE_CODE (t
);
1595 /* IDENTIFIER_NODEs should be singletons and are merged by the
1596 streamer. The others should be singletons, too, and we
1597 should not merge them in any way. */
1598 gcc_assert (code
!= TRANSLATION_UNIT_DECL
1599 && code
!= IDENTIFIER_NODE
1600 && !streamer_handle_as_builtin_p (t
));
1604 /* Fixup the streamer cache with the prevailing nodes according
1605 to the tree node mapping computed by compare_tree_sccs. */
1607 streamer_tree_cache_replace_tree (cache
, pscc
->entries
[0], from
);
1610 tree
*map2
= XALLOCAVEC (tree
, 2 * len
);
1611 for (unsigned i
= 0; i
< len
; ++i
)
1613 map2
[i
*2] = (tree
)(uintptr_t)(from
+ i
);
1614 map2
[i
*2+1] = scc
->entries
[i
];
1616 qsort (map2
, len
, 2 * sizeof (tree
), cmp_tree
);
1617 qsort (map
, len
, 2 * sizeof (tree
), cmp_tree
);
1618 for (unsigned i
= 0; i
< len
; ++i
)
1619 streamer_tree_cache_replace_tree (cache
, map
[2*i
],
1620 (uintptr_t)map2
[2*i
]);
1623 /* Free the tree nodes from the read SCC. */
1624 data_in
->location_cache
.revert_location_cache ();
1625 for (unsigned i
= 0; i
< len
; ++i
)
1627 enum tree_code code
;
1628 if (TYPE_P (scc
->entries
[i
]))
1630 code
= TREE_CODE (scc
->entries
[i
]);
1631 if (CODE_CONTAINS_STRUCT (code
, TS_CONSTRUCTOR
))
1632 vec_free (CONSTRUCTOR_ELTS (scc
->entries
[i
]));
1633 ggc_free (scc
->entries
[i
]);
1639 /* Reset TREE_VISITED if we didn't unify the SCC with another. */
1641 for (unsigned i
= 0; i
< scc
->len
; ++i
)
1642 TREE_VISITED (scc
->entries
[i
]) = 0;
1645 /* If we didn't unify it to any candidate duplicate the relevant
1646 pieces to permanent storage and link it into the chain. */
1650 = XOBNEWVAR (&tree_scc_hash_obstack
, tree_scc
, sizeof (tree_scc
));
1651 memcpy (pscc
, scc
, sizeof (tree_scc
));
1652 pscc
->next
= (*slot
);
1659 /* Read all the symbols from buffer DATA, using descriptors in DECL_DATA.
1660 RESOLUTIONS is the set of symbols picked by the linker (read from the
1661 resolution file when the linker plugin is being used). */
1664 lto_read_decls (struct lto_file_decl_data
*decl_data
, const void *data
,
1665 vec
<ld_plugin_symbol_resolution_t
> resolutions
)
1667 const struct lto_decl_header
*header
= (const struct lto_decl_header
*) data
;
1668 const int decl_offset
= sizeof (struct lto_decl_header
);
1669 const int main_offset
= decl_offset
+ header
->decl_state_size
;
1670 const int string_offset
= main_offset
+ header
->main_size
;
1671 struct data_in
*data_in
;
1673 const uint32_t *data_ptr
, *data_end
;
1674 uint32_t num_decl_states
;
1676 lto_input_block
ib_main ((const char *) data
+ main_offset
,
1677 header
->main_size
, decl_data
->mode_table
);
1679 data_in
= lto_data_in_create (decl_data
, (const char *) data
+ string_offset
,
1680 header
->string_size
, resolutions
);
1682 /* We do not uniquify the pre-loaded cache entries, those are middle-end
1683 internal types that should not be merged. */
1685 /* Read the global declarations and types. */
1686 while (ib_main
.p
< ib_main
.len
)
1689 unsigned from
= data_in
->reader_cache
->nodes
.length ();
1690 /* Read and uniquify SCCs as in the input stream. */
1691 enum LTO_tags tag
= streamer_read_record_start (&ib_main
);
1692 if (tag
== LTO_tree_scc
)
1695 unsigned scc_entry_len
;
1696 hashval_t scc_hash
= lto_input_scc (&ib_main
, data_in
, &len_
,
1698 unsigned len
= data_in
->reader_cache
->nodes
.length () - from
;
1699 gcc_assert (len
== len_
);
1701 total_scc_size
+= len
;
1704 /* We have the special case of size-1 SCCs that are pre-merged
1705 by means of identifier and string sharing for example.
1706 ??? Maybe we should avoid streaming those as SCCs. */
1707 tree first
= streamer_tree_cache_get_tree (data_in
->reader_cache
,
1710 && (TREE_CODE (first
) == IDENTIFIER_NODE
1711 || TREE_CODE (first
) == INTEGER_CST
1712 || TREE_CODE (first
) == TRANSLATION_UNIT_DECL
1713 || streamer_handle_as_builtin_p (first
)))
1716 /* Try to unify the SCC with already existing ones. */
1718 && unify_scc (data_in
, from
,
1719 len
, scc_entry_len
, scc_hash
))
1722 /* Tree merging failed, mark entries in location cache as
1724 data_in
->location_cache
.accept_location_cache ();
1726 bool seen_type
= false;
1727 for (unsigned i
= 0; i
< len
; ++i
)
1729 tree t
= streamer_tree_cache_get_tree (data_in
->reader_cache
,
1731 /* Reconstruct the type variant and pointer-to/reference-to
1736 num_prevailing_types
++;
1737 lto_fixup_prevailing_type (t
);
1739 /* Compute the canonical type of all types.
1740 ??? Should be able to assert that !TYPE_CANONICAL. */
1741 if (TYPE_P (t
) && !TYPE_CANONICAL (t
))
1743 gimple_register_canonical_type (t
);
1745 register_odr_type (t
);
1747 /* Link shared INTEGER_CSTs into TYPE_CACHED_VALUEs of its
1748 type which is also member of this SCC. */
1749 if (TREE_CODE (t
) == INTEGER_CST
1750 && !TREE_OVERFLOW (t
))
1751 cache_integer_cst (t
);
1752 /* Register TYPE_DECLs with the debuginfo machinery. */
1754 && TREE_CODE (t
) == TYPE_DECL
)
1756 /* Dwarf2out needs location information.
1757 TODO: Moving this out of the streamer loop may noticealy
1758 improve ltrans linemap memory use. */
1759 data_in
->location_cache
.apply_location_cache ();
1760 debug_hooks
->type_decl (t
, !DECL_FILE_SCOPE_P (t
));
1764 /* Register variables and functions with the
1766 if (TREE_CODE (t
) == VAR_DECL
)
1767 lto_register_var_decl_in_symtab (data_in
, t
, from
+ i
);
1768 else if (TREE_CODE (t
) == FUNCTION_DECL
1769 && !DECL_BUILT_IN (t
))
1770 lto_register_function_decl_in_symtab (data_in
, t
, from
+ i
);
1771 /* Scan the tree for references to global functions or
1772 variables and record those for later fixup. */
1773 if (mentions_vars_p (t
))
1774 vec_safe_push (tree_with_vars
, t
);
1778 num_type_scc_trees
+= len
;
1782 /* Pickle stray references. */
1783 t
= lto_input_tree_1 (&ib_main
, data_in
, tag
, 0);
1784 gcc_assert (t
&& data_in
->reader_cache
->nodes
.length () == from
);
1787 data_in
->location_cache
.apply_location_cache ();
1789 /* Read in lto_in_decl_state objects. */
1790 data_ptr
= (const uint32_t *) ((const char*) data
+ decl_offset
);
1792 (const uint32_t *) ((const char*) data_ptr
+ header
->decl_state_size
);
1793 num_decl_states
= *data_ptr
++;
1795 gcc_assert (num_decl_states
> 0);
1796 decl_data
->global_decl_state
= lto_new_in_decl_state ();
1797 data_ptr
= lto_read_in_decl_state (data_in
, data_ptr
,
1798 decl_data
->global_decl_state
);
1800 /* Read in per-function decl states and enter them in hash table. */
1801 decl_data
->function_decl_states
=
1802 hash_table
<decl_state_hasher
>::create_ggc (37);
1804 for (i
= 1; i
< num_decl_states
; i
++)
1806 struct lto_in_decl_state
*state
= lto_new_in_decl_state ();
1808 data_ptr
= lto_read_in_decl_state (data_in
, data_ptr
, state
);
1809 lto_in_decl_state
**slot
1810 = decl_data
->function_decl_states
->find_slot (state
, INSERT
);
1811 gcc_assert (*slot
== NULL
);
1815 if (data_ptr
!= data_end
)
1816 internal_error ("bytecode stream: garbage at the end of symbols section");
1818 /* Set the current decl state to be the global state. */
1819 decl_data
->current_decl_state
= decl_data
->global_decl_state
;
1821 lto_data_in_delete (data_in
);
1824 /* Custom version of strtoll, which is not portable. */
1827 lto_parse_hex (const char *p
)
1831 for (; *p
!= '\0'; ++p
)
1836 if (c
>= '0' && c
<= '9')
1838 else if (c
>= 'a' && c
<= 'f')
1839 part
= c
- 'a' + 10;
1840 else if (c
>= 'A' && c
<= 'F')
1841 part
= c
- 'A' + 10;
1843 internal_error ("could not parse hex number");
1850 /* Read resolution for file named FILE_NAME. The resolution is read from
1854 lto_resolution_read (splay_tree file_ids
, FILE *resolution
, lto_file
*file
)
1856 /* We require that objects in the resolution file are in the same
1857 order as the lto1 command line. */
1858 unsigned int name_len
;
1860 unsigned int num_symbols
;
1862 struct lto_file_decl_data
*file_data
;
1863 splay_tree_node nd
= NULL
;
1868 name_len
= strlen (file
->filename
);
1869 obj_name
= XNEWVEC (char, name_len
+ 1);
1870 fscanf (resolution
, " "); /* Read white space. */
1872 fread (obj_name
, sizeof (char), name_len
, resolution
);
1873 obj_name
[name_len
] = '\0';
1874 if (filename_cmp (obj_name
, file
->filename
) != 0)
1875 internal_error ("unexpected file name %s in linker resolution file. "
1876 "Expected %s", obj_name
, file
->filename
);
1877 if (file
->offset
!= 0)
1882 t
= fscanf (resolution
, "@0x%16s", offset_p
);
1884 internal_error ("could not parse file offset");
1885 offset
= lto_parse_hex (offset_p
);
1886 if (offset
!= file
->offset
)
1887 internal_error ("unexpected offset");
1892 fscanf (resolution
, "%u", &num_symbols
);
1894 for (i
= 0; i
< num_symbols
; i
++)
1898 unsigned HOST_WIDE_INT id
;
1900 enum ld_plugin_symbol_resolution r
= (enum ld_plugin_symbol_resolution
) 0;
1902 unsigned int lto_resolution_str_len
=
1903 sizeof (lto_resolution_str
) / sizeof (char *);
1906 t
= fscanf (resolution
, "%u " HOST_WIDE_INT_PRINT_HEX_PURE
" %26s %*[^\n]\n",
1907 &index
, &id
, r_str
);
1909 internal_error ("invalid line in the resolution file");
1911 for (j
= 0; j
< lto_resolution_str_len
; j
++)
1913 if (strcmp (lto_resolution_str
[j
], r_str
) == 0)
1915 r
= (enum ld_plugin_symbol_resolution
) j
;
1919 if (j
== lto_resolution_str_len
)
1920 internal_error ("invalid resolution in the resolution file");
1922 if (!(nd
&& lto_splay_tree_id_equal_p (nd
->key
, id
)))
1924 nd
= lto_splay_tree_lookup (file_ids
, id
);
1926 internal_error ("resolution sub id %wx not in object file", id
);
1929 file_data
= (struct lto_file_decl_data
*)nd
->value
;
1930 /* The indexes are very sparse. To save memory save them in a compact
1931 format that is only unpacked later when the subfile is processed. */
1934 file_data
->respairs
.safe_push (rp
);
1935 if (file_data
->max_index
< index
)
1936 file_data
->max_index
= index
;
1940 /* List of file_decl_datas */
1941 struct file_data_list
1943 struct lto_file_decl_data
*first
, *last
;
1946 /* Is the name for a id'ed LTO section? */
1949 lto_section_with_id (const char *name
, unsigned HOST_WIDE_INT
*id
)
1953 if (strncmp (name
, section_name_prefix
, strlen (section_name_prefix
)))
1955 s
= strrchr (name
, '.');
1956 return s
&& sscanf (s
, "." HOST_WIDE_INT_PRINT_HEX_PURE
, id
) == 1;
1959 /* Create file_data of each sub file id */
1962 create_subid_section_table (struct lto_section_slot
*ls
, splay_tree file_ids
,
1963 struct file_data_list
*list
)
1965 struct lto_section_slot s_slot
, *new_slot
;
1966 unsigned HOST_WIDE_INT id
;
1970 struct lto_file_decl_data
*file_data
;
1972 if (!lto_section_with_id (ls
->name
, &id
))
1975 /* Find hash table of sub module id */
1976 nd
= lto_splay_tree_lookup (file_ids
, id
);
1979 file_data
= (struct lto_file_decl_data
*)nd
->value
;
1983 file_data
= ggc_alloc
<lto_file_decl_data
> ();
1984 memset(file_data
, 0, sizeof (struct lto_file_decl_data
));
1986 file_data
->section_hash_table
= lto_obj_create_section_hash_table ();;
1987 lto_splay_tree_insert (file_ids
, id
, file_data
);
1989 /* Maintain list in linker order */
1991 list
->first
= file_data
;
1993 list
->last
->next
= file_data
;
1994 list
->last
= file_data
;
1997 /* Copy section into sub module hash table */
1998 new_name
= XDUPVEC (char, ls
->name
, strlen (ls
->name
) + 1);
1999 s_slot
.name
= new_name
;
2000 hash_slot
= htab_find_slot (file_data
->section_hash_table
, &s_slot
, INSERT
);
2001 gcc_assert (*hash_slot
== NULL
);
2003 new_slot
= XDUP (struct lto_section_slot
, ls
);
2004 new_slot
->name
= new_name
;
2005 *hash_slot
= new_slot
;
2009 /* Read declarations and other initializations for a FILE_DATA. */
2012 lto_file_finalize (struct lto_file_decl_data
*file_data
, lto_file
*file
)
2016 vec
<ld_plugin_symbol_resolution_t
>
2017 resolutions
= vNULL
;
2021 /* Create vector for fast access of resolution. We do this lazily
2023 resolutions
.safe_grow_cleared (file_data
->max_index
+ 1);
2024 for (i
= 0; file_data
->respairs
.iterate (i
, &rp
); i
++)
2025 resolutions
[rp
->index
] = rp
->res
;
2026 file_data
->respairs
.release ();
2028 file_data
->renaming_hash_table
= lto_create_renaming_table ();
2029 file_data
->file_name
= file
->filename
;
2030 #ifdef ACCEL_COMPILER
2031 lto_input_mode_table (file_data
);
2033 file_data
->mode_table
= lto_mode_identity_table
;
2035 data
= lto_get_section_data (file_data
, LTO_section_decls
, NULL
, &len
);
2038 internal_error ("cannot read LTO decls from %s", file_data
->file_name
);
2041 /* Frees resolutions */
2042 lto_read_decls (file_data
, data
, resolutions
);
2043 lto_free_section_data (file_data
, LTO_section_decls
, NULL
, data
, len
);
2046 /* Finalize FILE_DATA in FILE and increase COUNT. */
2049 lto_create_files_from_ids (lto_file
*file
, struct lto_file_decl_data
*file_data
,
2052 lto_file_finalize (file_data
, file
);
2053 if (symtab
->dump_file
)
2054 fprintf (symtab
->dump_file
,
2055 "Creating file %s with sub id " HOST_WIDE_INT_PRINT_HEX
"\n",
2056 file_data
->file_name
, file_data
->id
);
2061 /* Generate a TREE representation for all types and external decls
2064 Read all of the globals out of the file. Then read the cgraph
2065 and process the .o index into the cgraph nodes so that it can open
2066 the .o file to load the functions and ipa information. */
2068 static struct lto_file_decl_data
*
2069 lto_file_read (lto_file
*file
, FILE *resolution_file
, int *count
)
2071 struct lto_file_decl_data
*file_data
= NULL
;
2072 splay_tree file_ids
;
2073 htab_t section_hash_table
;
2074 struct lto_section_slot
*section
;
2075 struct file_data_list file_list
;
2076 struct lto_section_list section_list
;
2078 memset (§ion_list
, 0, sizeof (struct lto_section_list
));
2079 section_hash_table
= lto_obj_build_section_table (file
, §ion_list
);
2081 /* Find all sub modules in the object and put their sections into new hash
2082 tables in a splay tree. */
2083 file_ids
= lto_splay_tree_new ();
2084 memset (&file_list
, 0, sizeof (struct file_data_list
));
2085 for (section
= section_list
.first
; section
!= NULL
; section
= section
->next
)
2086 create_subid_section_table (section
, file_ids
, &file_list
);
2088 /* Add resolutions to file ids */
2089 lto_resolution_read (file_ids
, resolution_file
, file
);
2091 /* Finalize each lto file for each submodule in the merged object */
2092 for (file_data
= file_list
.first
; file_data
!= NULL
; file_data
= file_data
->next
)
2093 lto_create_files_from_ids (file
, file_data
, count
);
2095 splay_tree_delete (file_ids
);
2096 htab_delete (section_hash_table
);
2098 return file_list
.first
;
2101 #if HAVE_MMAP_FILE && HAVE_SYSCONF && defined _SC_PAGE_SIZE
2102 #define LTO_MMAP_IO 1
2106 /* Page size of machine is used for mmap and munmap calls. */
2107 static size_t page_mask
;
2110 /* Get the section data of length LEN from FILENAME starting at
2111 OFFSET. The data segment must be freed by the caller when the
2112 caller is finished. Returns NULL if all was not well. */
2115 lto_read_section_data (struct lto_file_decl_data
*file_data
,
2116 intptr_t offset
, size_t len
)
2120 static char *fd_name
;
2122 intptr_t computed_len
;
2123 intptr_t computed_offset
;
2127 /* Keep a single-entry file-descriptor cache. The last file we
2128 touched will get closed at exit.
2129 ??? Eventually we want to add a more sophisticated larger cache
2130 or rather fix function body streaming to not stream them in
2131 practically random order. */
2133 && filename_cmp (fd_name
, file_data
->file_name
) != 0)
2141 fd
= open (file_data
->file_name
, O_RDONLY
|O_BINARY
);
2144 fatal_error (input_location
, "Cannot open %s", file_data
->file_name
);
2147 fd_name
= xstrdup (file_data
->file_name
);
2153 size_t page_size
= sysconf (_SC_PAGE_SIZE
);
2154 page_mask
= ~(page_size
- 1);
2157 computed_offset
= offset
& page_mask
;
2158 diff
= offset
- computed_offset
;
2159 computed_len
= len
+ diff
;
2161 result
= (char *) mmap (NULL
, computed_len
, PROT_READ
, MAP_PRIVATE
,
2162 fd
, computed_offset
);
2163 if (result
== MAP_FAILED
)
2165 fatal_error (input_location
, "Cannot map %s", file_data
->file_name
);
2169 return result
+ diff
;
2171 result
= (char *) xmalloc (len
);
2172 if (lseek (fd
, offset
, SEEK_SET
) != offset
2173 || read (fd
, result
, len
) != (ssize_t
) len
)
2176 fatal_error (input_location
, "Cannot read %s", file_data
->file_name
);
2180 /* Native windows doesn't supports delayed unlink on opened file. So
2181 we close file here again. This produces higher I/O load, but at least
2182 it prevents to have dangling file handles preventing unlink. */
2193 /* Get the section data from FILE_DATA of SECTION_TYPE with NAME.
2194 NAME will be NULL unless the section type is for a function
2198 get_section_data (struct lto_file_decl_data
*file_data
,
2199 enum lto_section_type section_type
,
2203 htab_t section_hash_table
= file_data
->section_hash_table
;
2204 struct lto_section_slot
*f_slot
;
2205 struct lto_section_slot s_slot
;
2206 const char *section_name
= lto_get_section_name (section_type
, name
, file_data
);
2210 s_slot
.name
= section_name
;
2211 f_slot
= (struct lto_section_slot
*) htab_find (section_hash_table
, &s_slot
);
2214 data
= lto_read_section_data (file_data
, f_slot
->start
, f_slot
->len
);
2218 free (CONST_CAST (char *, section_name
));
2223 /* Free the section data from FILE_DATA of SECTION_TYPE with NAME that
2224 starts at OFFSET and has LEN bytes. */
2227 free_section_data (struct lto_file_decl_data
*file_data ATTRIBUTE_UNUSED
,
2228 enum lto_section_type section_type ATTRIBUTE_UNUSED
,
2229 const char *name ATTRIBUTE_UNUSED
,
2230 const char *offset
, size_t len ATTRIBUTE_UNUSED
)
2233 intptr_t computed_len
;
2234 intptr_t computed_offset
;
2239 computed_offset
= ((intptr_t) offset
) & page_mask
;
2240 diff
= (intptr_t) offset
- computed_offset
;
2241 computed_len
= len
+ diff
;
2243 munmap ((caddr_t
) computed_offset
, computed_len
);
2245 free (CONST_CAST(char *, offset
));
2249 static lto_file
*current_lto_file
;
2251 /* Helper for qsort; compare partitions and return one with smaller size.
2252 We sort from greatest to smallest so parallel build doesn't stale on the
2253 longest compilation being executed too late. */
2256 cmp_partitions_size (const void *a
, const void *b
)
2258 const struct ltrans_partition_def
*pa
2259 = *(struct ltrans_partition_def
*const *)a
;
2260 const struct ltrans_partition_def
*pb
2261 = *(struct ltrans_partition_def
*const *)b
;
2262 return pb
->insns
- pa
->insns
;
2265 /* Helper for qsort; compare partitions and return one with smaller order. */
2268 cmp_partitions_order (const void *a
, const void *b
)
2270 const struct ltrans_partition_def
*pa
2271 = *(struct ltrans_partition_def
*const *)a
;
2272 const struct ltrans_partition_def
*pb
2273 = *(struct ltrans_partition_def
*const *)b
;
2274 int ordera
= -1, orderb
= -1;
2276 if (lto_symtab_encoder_size (pa
->encoder
))
2277 ordera
= lto_symtab_encoder_deref (pa
->encoder
, 0)->order
;
2278 if (lto_symtab_encoder_size (pb
->encoder
))
2279 orderb
= lto_symtab_encoder_deref (pb
->encoder
, 0)->order
;
2280 return orderb
- ordera
;
2283 /* Actually stream out ENCODER into TEMP_FILENAME. */
2286 do_stream_out (char *temp_filename
, lto_symtab_encoder_t encoder
)
2288 lto_file
*file
= lto_obj_file_open (temp_filename
, true);
2290 fatal_error (input_location
, "lto_obj_file_open() failed");
2291 lto_set_current_out_file (file
);
2293 ipa_write_optimization_summaries (encoder
);
2295 lto_set_current_out_file (NULL
);
2296 lto_obj_file_close (file
);
2300 /* Wait for forked process and signal errors. */
2301 #ifdef HAVE_WORKING_FORK
2309 #define WCONTINUED 0
2311 int w
= waitpid (0, &status
, WUNTRACED
| WCONTINUED
);
2313 fatal_error (input_location
, "waitpid failed");
2315 if (WIFEXITED (status
) && WEXITSTATUS (status
))
2316 fatal_error (input_location
, "streaming subprocess failed");
2317 else if (WIFSIGNALED (status
))
2318 fatal_error (input_location
,
2319 "streaming subprocess was killed by signal");
2321 while (!WIFEXITED (status
) && !WIFSIGNALED (status
));
2325 /* Stream out ENCODER into TEMP_FILENAME
2326 Fork if that seems to help. */
2329 stream_out (char *temp_filename
, lto_symtab_encoder_t encoder
,
2330 bool ARG_UNUSED (last
))
2332 #ifdef HAVE_WORKING_FORK
2335 if (lto_parallelism
<= 1)
2337 do_stream_out (temp_filename
, encoder
);
2341 /* Do not run more than LTO_PARALLELISM streamings
2342 FIXME: we ignore limits on jobserver. */
2343 if (lto_parallelism
> 0 && nruns
>= lto_parallelism
)
2348 /* If this is not the last parallel partition, execute new
2349 streaming process. */
2352 pid_t cpid
= fork ();
2356 setproctitle ("lto1-wpa-streaming");
2357 do_stream_out (temp_filename
, encoder
);
2360 /* Fork failed; lets do the job ourseleves. */
2361 else if (cpid
== -1)
2362 do_stream_out (temp_filename
, encoder
);
2366 /* Last partition; stream it and wait for all children to die. */
2370 do_stream_out (temp_filename
, encoder
);
2371 for (i
= 0; i
< nruns
; i
++)
2374 asm_nodes_output
= true;
2376 do_stream_out (temp_filename
, encoder
);
2380 /* Write all output files in WPA mode and the file with the list of
2384 lto_wpa_write_files (void)
2387 ltrans_partition part
;
2388 FILE *ltrans_output_list_stream
;
2389 char *temp_filename
;
2390 vec
<char *>temp_filenames
= vNULL
;
2393 /* Open the LTRANS output list. */
2394 if (!ltrans_output_list
)
2395 fatal_error (input_location
, "no LTRANS output list filename provided");
2397 timevar_push (TV_WHOPR_WPA
);
2399 FOR_EACH_VEC_ELT (ltrans_partitions
, i
, part
)
2400 lto_stats
.num_output_symtab_nodes
+= lto_symtab_encoder_size (part
->encoder
);
2402 timevar_pop (TV_WHOPR_WPA
);
2404 timevar_push (TV_WHOPR_WPA_IO
);
2406 /* Generate a prefix for the LTRANS unit files. */
2407 blen
= strlen (ltrans_output_list
);
2408 temp_filename
= (char *) xmalloc (blen
+ sizeof ("2147483648.o"));
2409 strcpy (temp_filename
, ltrans_output_list
);
2410 if (blen
> sizeof (".out")
2411 && strcmp (temp_filename
+ blen
- sizeof (".out") + 1,
2413 temp_filename
[blen
- sizeof (".out") + 1] = '\0';
2414 blen
= strlen (temp_filename
);
2416 n_sets
= ltrans_partitions
.length ();
2418 /* Sort partitions by size so small ones are compiled last.
2419 FIXME: Even when not reordering we may want to output one list for parallel make
2420 and other for final link command. */
2422 if (!flag_profile_reorder_functions
|| !flag_profile_use
)
2423 ltrans_partitions
.qsort (flag_toplevel_reorder
2424 ? cmp_partitions_size
2425 : cmp_partitions_order
);
2427 for (i
= 0; i
< n_sets
; i
++)
2429 ltrans_partition part
= ltrans_partitions
[i
];
2431 /* Write all the nodes in SET. */
2432 sprintf (temp_filename
+ blen
, "%u.o", i
);
2435 fprintf (stderr
, " %s (%s %i insns)", temp_filename
, part
->name
, part
->insns
);
2436 if (symtab
->dump_file
)
2438 lto_symtab_encoder_iterator lsei
;
2440 fprintf (symtab
->dump_file
, "Writing partition %s to file %s, %i insns\n",
2441 part
->name
, temp_filename
, part
->insns
);
2442 fprintf (symtab
->dump_file
, " Symbols in partition: ");
2443 for (lsei
= lsei_start_in_partition (part
->encoder
); !lsei_end_p (lsei
);
2444 lsei_next_in_partition (&lsei
))
2446 symtab_node
*node
= lsei_node (lsei
);
2447 fprintf (symtab
->dump_file
, "%s ", node
->asm_name ());
2449 fprintf (symtab
->dump_file
, "\n Symbols in boundary: ");
2450 for (lsei
= lsei_start (part
->encoder
); !lsei_end_p (lsei
);
2453 symtab_node
*node
= lsei_node (lsei
);
2454 if (!lto_symtab_encoder_in_partition_p (part
->encoder
, node
))
2456 fprintf (symtab
->dump_file
, "%s ", node
->asm_name ());
2457 cgraph_node
*cnode
= dyn_cast
<cgraph_node
*> (node
);
2459 && lto_symtab_encoder_encode_body_p (part
->encoder
, cnode
))
2460 fprintf (symtab
->dump_file
, "(body included)");
2463 varpool_node
*vnode
= dyn_cast
<varpool_node
*> (node
);
2465 && lto_symtab_encoder_encode_initializer_p (part
->encoder
, vnode
))
2466 fprintf (symtab
->dump_file
, "(initializer included)");
2470 fprintf (symtab
->dump_file
, "\n");
2472 gcc_checking_assert (lto_symtab_encoder_size (part
->encoder
) || !i
);
2474 stream_out (temp_filename
, part
->encoder
, i
== n_sets
- 1);
2476 part
->encoder
= NULL
;
2478 temp_filenames
.safe_push (xstrdup (temp_filename
));
2480 ltrans_output_list_stream
= fopen (ltrans_output_list
, "w");
2481 if (ltrans_output_list_stream
== NULL
)
2482 fatal_error (input_location
,
2483 "opening LTRANS output list %s: %m", ltrans_output_list
);
2484 for (i
= 0; i
< n_sets
; i
++)
2486 unsigned int len
= strlen (temp_filenames
[i
]);
2487 if (fwrite (temp_filenames
[i
], 1, len
, ltrans_output_list_stream
) < len
2488 || fwrite ("\n", 1, 1, ltrans_output_list_stream
) < 1)
2489 fatal_error (input_location
, "writing to LTRANS output list %s: %m",
2490 ltrans_output_list
);
2491 free (temp_filenames
[i
]);
2493 temp_filenames
.release();
2495 lto_stats
.num_output_files
+= n_sets
;
2497 /* Close the LTRANS output list. */
2498 if (fclose (ltrans_output_list_stream
))
2499 fatal_error (input_location
,
2500 "closing LTRANS output list %s: %m", ltrans_output_list
);
2502 free_ltrans_partitions();
2503 free (temp_filename
);
2505 timevar_pop (TV_WHOPR_WPA_IO
);
2509 /* If TT is a variable or function decl replace it with its
2510 prevailing variant. */
2511 #define LTO_SET_PREVAIL(tt) \
2513 if ((tt) && VAR_OR_FUNCTION_DECL_P (tt) \
2514 && (TREE_PUBLIC (tt) || DECL_EXTERNAL (tt))) \
2516 tt = lto_symtab_prevailing_decl (tt); \
2521 /* Ensure that TT isn't a replacable var of function decl. */
2522 #define LTO_NO_PREVAIL(tt) \
2523 gcc_assert (!(tt) || !VAR_OR_FUNCTION_DECL_P (tt))
2525 /* Given a tree T replace all fields referring to variables or functions
2526 with their prevailing variant. */
2528 lto_fixup_prevailing_decls (tree t
)
2530 enum tree_code code
= TREE_CODE (t
);
2533 gcc_checking_assert (code
!= TREE_BINFO
);
2534 LTO_NO_PREVAIL (TREE_TYPE (t
));
2535 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
2536 LTO_NO_PREVAIL (TREE_CHAIN (t
));
2539 LTO_NO_PREVAIL (DECL_NAME (t
));
2540 LTO_SET_PREVAIL (DECL_CONTEXT (t
));
2541 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
2543 LTO_SET_PREVAIL (DECL_SIZE (t
));
2544 LTO_SET_PREVAIL (DECL_SIZE_UNIT (t
));
2545 LTO_SET_PREVAIL (DECL_INITIAL (t
));
2546 LTO_NO_PREVAIL (DECL_ATTRIBUTES (t
));
2547 LTO_SET_PREVAIL (DECL_ABSTRACT_ORIGIN (t
));
2549 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
2551 LTO_NO_PREVAIL (t
->decl_with_vis
.assembler_name
);
2553 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
2555 LTO_NO_PREVAIL (DECL_RESULT_FLD (t
));
2557 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
2559 LTO_NO_PREVAIL (DECL_ARGUMENTS (t
));
2560 LTO_SET_PREVAIL (DECL_FUNCTION_PERSONALITY (t
));
2561 LTO_NO_PREVAIL (DECL_VINDEX (t
));
2563 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
2565 LTO_SET_PREVAIL (DECL_FIELD_OFFSET (t
));
2566 LTO_NO_PREVAIL (DECL_BIT_FIELD_TYPE (t
));
2567 LTO_NO_PREVAIL (DECL_QUALIFIER (t
));
2568 LTO_NO_PREVAIL (DECL_FIELD_BIT_OFFSET (t
));
2569 LTO_NO_PREVAIL (DECL_FCONTEXT (t
));
2572 else if (TYPE_P (t
))
2574 LTO_NO_PREVAIL (TYPE_CACHED_VALUES (t
));
2575 LTO_SET_PREVAIL (TYPE_SIZE (t
));
2576 LTO_SET_PREVAIL (TYPE_SIZE_UNIT (t
));
2577 LTO_NO_PREVAIL (TYPE_ATTRIBUTES (t
));
2578 LTO_NO_PREVAIL (TYPE_NAME (t
));
2580 LTO_SET_PREVAIL (TYPE_MINVAL (t
));
2581 LTO_SET_PREVAIL (TYPE_MAXVAL (t
));
2582 LTO_NO_PREVAIL (t
->type_non_common
.binfo
);
2584 LTO_SET_PREVAIL (TYPE_CONTEXT (t
));
2586 LTO_NO_PREVAIL (TYPE_CANONICAL (t
));
2587 LTO_NO_PREVAIL (TYPE_MAIN_VARIANT (t
));
2588 LTO_NO_PREVAIL (TYPE_NEXT_VARIANT (t
));
2590 else if (EXPR_P (t
))
2593 for (i
= TREE_OPERAND_LENGTH (t
) - 1; i
>= 0; --i
)
2594 LTO_SET_PREVAIL (TREE_OPERAND (t
, i
));
2596 else if (TREE_CODE (t
) == CONSTRUCTOR
)
2600 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (t
), i
, val
)
2601 LTO_SET_PREVAIL (val
);
2608 LTO_SET_PREVAIL (TREE_VALUE (t
));
2609 LTO_SET_PREVAIL (TREE_PURPOSE (t
));
2610 LTO_NO_PREVAIL (TREE_PURPOSE (t
));
2616 /* If we fixed nothing, then we missed something seen by
2618 gcc_checking_assert (fixed
);
2620 #undef LTO_SET_PREVAIL
2621 #undef LTO_NO_PREVAIL
2623 /* Helper function of lto_fixup_decls. Walks the var and fn streams in STATE,
2624 replaces var and function decls with the corresponding prevailing def. */
2627 lto_fixup_state (struct lto_in_decl_state
*state
)
2631 /* Although we only want to replace FUNCTION_DECLs and VAR_DECLs,
2632 we still need to walk from all DECLs to find the reachable
2633 FUNCTION_DECLs and VAR_DECLs. */
2634 for (si
= 0; si
< LTO_N_DECL_STREAMS
; si
++)
2636 vec
<tree
, va_gc
> *trees
= state
->streams
[si
];
2637 for (i
= 0; i
< vec_safe_length (trees
); i
++)
2639 tree t
= (*trees
)[i
];
2640 #ifdef ENABLE_CHECKING
2644 if (VAR_OR_FUNCTION_DECL_P (t
)
2645 && (TREE_PUBLIC (t
) || DECL_EXTERNAL (t
)))
2646 (*trees
)[i
] = lto_symtab_prevailing_decl (t
);
2651 /* Fix the decls from all FILES. Replaces each decl with the corresponding
2655 lto_fixup_decls (struct lto_file_decl_data
**files
)
2661 FOR_EACH_VEC_ELT ((*tree_with_vars
), i
, t
)
2662 lto_fixup_prevailing_decls (t
);
2664 for (i
= 0; files
[i
]; i
++)
2666 struct lto_file_decl_data
*file
= files
[i
];
2667 struct lto_in_decl_state
*state
= file
->global_decl_state
;
2668 lto_fixup_state (state
);
2670 hash_table
<decl_state_hasher
>::iterator iter
;
2671 lto_in_decl_state
*elt
;
2672 FOR_EACH_HASH_TABLE_ELEMENT (*file
->function_decl_states
, elt
,
2673 lto_in_decl_state
*, iter
)
2674 lto_fixup_state (elt
);
2678 static GTY((length ("lto_stats.num_input_files + 1"))) struct lto_file_decl_data
**all_file_decl_data
;
2680 /* Turn file datas for sub files into a single array, so that they look
2681 like separate files for further passes. */
2684 lto_flatten_files (struct lto_file_decl_data
**orig
, int count
, int last_file_ix
)
2686 struct lto_file_decl_data
*n
, *next
;
2689 lto_stats
.num_input_files
= count
;
2691 = ggc_cleared_vec_alloc
<lto_file_decl_data_ptr
> (count
+ 1);
2692 /* Set the hooks so that all of the ipa passes can read in their data. */
2693 lto_set_in_hooks (all_file_decl_data
, get_section_data
, free_section_data
);
2694 for (i
= 0, k
= 0; i
< last_file_ix
; i
++)
2696 for (n
= orig
[i
]; n
!= NULL
; n
= next
)
2698 all_file_decl_data
[k
++] = n
;
2703 all_file_decl_data
[k
] = NULL
;
2704 gcc_assert (k
== count
);
2707 /* Input file data before flattening (i.e. splitting them to subfiles to support
2708 incremental linking. */
2709 static int real_file_count
;
2710 static GTY((length ("real_file_count + 1"))) struct lto_file_decl_data
**real_file_decl_data
;
2712 static void print_lto_report_1 (void);
2714 /* Read all the symbols from the input files FNAMES. NFILES is the
2715 number of files requested in the command line. Instantiate a
2716 global call graph by aggregating all the sub-graphs found in each
2720 read_cgraph_and_symbols (unsigned nfiles
, const char **fnames
)
2722 unsigned int i
, last_file_ix
;
2725 struct lto_file_decl_data
**decl_data
;
2728 symtab
->initialize ();
2730 timevar_push (TV_IPA_LTO_DECL_IN
);
2732 #ifdef ACCEL_COMPILER
2733 section_name_prefix
= OFFLOAD_SECTION_NAME_PREFIX
;
2734 lto_stream_offload_p
= true;
2738 = decl_data
= ggc_cleared_vec_alloc
<lto_file_decl_data_ptr
> (nfiles
+ 1);
2739 real_file_count
= nfiles
;
2741 /* Read the resolution file. */
2743 if (resolution_file_name
)
2746 unsigned num_objects
;
2748 resolution
= fopen (resolution_file_name
, "r");
2749 if (resolution
== NULL
)
2750 fatal_error (input_location
,
2751 "could not open symbol resolution file: %m");
2753 t
= fscanf (resolution
, "%u", &num_objects
);
2754 gcc_assert (t
== 1);
2756 /* True, since the plugin splits the archives. */
2757 gcc_assert (num_objects
== nfiles
);
2759 symtab
->state
= LTO_STREAMING
;
2761 canonical_type_hash_cache
= new hash_map
<const_tree
, hashval_t
> (251);
2762 gimple_canonical_types
= htab_create (16381, gimple_canonical_type_hash
,
2763 gimple_canonical_type_eq
, NULL
);
2764 gcc_obstack_init (&tree_scc_hash_obstack
);
2765 tree_scc_hash
= new hash_table
<tree_scc_hasher
> (4096);
2767 /* Register the common node types with the canonical type machinery so
2768 we properly share alias-sets across languages and TUs. Do not
2769 expose the common nodes as type merge target - those that should be
2770 are already exposed so by pre-loading the LTO streamer caches.
2771 Do two passes - first clear TYPE_CANONICAL and then re-compute it. */
2772 for (i
= 0; i
< itk_none
; ++i
)
2773 lto_register_canonical_types (integer_types
[i
], true);
2774 for (i
= 0; i
< stk_type_kind_last
; ++i
)
2775 lto_register_canonical_types (sizetype_tab
[i
], true);
2776 for (i
= 0; i
< TI_MAX
; ++i
)
2777 lto_register_canonical_types (global_trees
[i
], true);
2778 for (i
= 0; i
< itk_none
; ++i
)
2779 lto_register_canonical_types (integer_types
[i
], false);
2780 for (i
= 0; i
< stk_type_kind_last
; ++i
)
2781 lto_register_canonical_types (sizetype_tab
[i
], false);
2782 for (i
= 0; i
< TI_MAX
; ++i
)
2783 lto_register_canonical_types (global_trees
[i
], false);
2786 fprintf (stderr
, "Reading object files:");
2788 /* Read all of the object files specified on the command line. */
2789 for (i
= 0, last_file_ix
= 0; i
< nfiles
; ++i
)
2791 struct lto_file_decl_data
*file_data
= NULL
;
2794 fprintf (stderr
, " %s", fnames
[i
]);
2798 current_lto_file
= lto_obj_file_open (fnames
[i
], false);
2799 if (!current_lto_file
)
2802 file_data
= lto_file_read (current_lto_file
, resolution
, &count
);
2805 lto_obj_file_close (current_lto_file
);
2806 free (current_lto_file
);
2807 current_lto_file
= NULL
;
2811 decl_data
[last_file_ix
++] = file_data
;
2813 lto_obj_file_close (current_lto_file
);
2814 free (current_lto_file
);
2815 current_lto_file
= NULL
;
2818 lto_flatten_files (decl_data
, count
, last_file_ix
);
2819 lto_stats
.num_input_files
= count
;
2820 ggc_free(decl_data
);
2821 real_file_decl_data
= NULL
;
2823 if (resolution_file_name
)
2824 fclose (resolution
);
2826 /* Show the LTO report before launching LTRANS. */
2827 if (flag_lto_report
|| (flag_wpa
&& flag_lto_report_wpa
))
2828 print_lto_report_1 ();
2830 /* Free gimple type merging datastructures. */
2831 delete tree_scc_hash
;
2832 tree_scc_hash
= NULL
;
2833 obstack_free (&tree_scc_hash_obstack
, NULL
);
2834 htab_delete (gimple_canonical_types
);
2835 gimple_canonical_types
= NULL
;
2836 delete canonical_type_hash_cache
;
2837 canonical_type_hash_cache
= NULL
;
2839 /* At this stage we know that majority of GGC memory is reachable.
2840 Growing the limits prevents unnecesary invocation of GGC. */
2844 /* Set the hooks so that all of the ipa passes can read in their data. */
2845 lto_set_in_hooks (all_file_decl_data
, get_section_data
, free_section_data
);
2847 timevar_pop (TV_IPA_LTO_DECL_IN
);
2850 fprintf (stderr
, "\nReading the callgraph\n");
2852 timevar_push (TV_IPA_LTO_CGRAPH_IO
);
2853 /* Read the symtab. */
2856 input_offload_tables ();
2858 /* Store resolutions into the symbol table. */
2860 ld_plugin_symbol_resolution_t
*res
;
2861 FOR_EACH_SYMBOL (snode
)
2862 if (snode
->real_symbol_p ()
2863 && snode
->lto_file_data
2864 && snode
->lto_file_data
->resolution_map
2865 && (res
= snode
->lto_file_data
->resolution_map
->get (snode
->decl
)))
2866 snode
->resolution
= *res
;
2867 for (i
= 0; all_file_decl_data
[i
]; i
++)
2868 if (all_file_decl_data
[i
]->resolution_map
)
2870 delete all_file_decl_data
[i
]->resolution_map
;
2871 all_file_decl_data
[i
]->resolution_map
= NULL
;
2874 timevar_pop (TV_IPA_LTO_CGRAPH_IO
);
2877 fprintf (stderr
, "Merging declarations\n");
2879 timevar_push (TV_IPA_LTO_DECL_MERGE
);
2880 /* Merge global decls. In ltrans mode we read merged cgraph, we do not
2881 need to care about resolving symbols again, we only need to replace
2882 duplicated declarations read from the callgraph and from function
2886 lto_symtab_merge_decls ();
2888 /* If there were errors during symbol merging bail out, we have no
2889 good way to recover here. */
2891 fatal_error (input_location
,
2892 "errors during merging of translation units");
2894 /* Fixup all decls. */
2895 lto_fixup_decls (all_file_decl_data
);
2898 ggc_free (tree_with_vars
);
2899 tree_with_vars
= NULL
;
2902 timevar_pop (TV_IPA_LTO_DECL_MERGE
);
2903 /* Each pass will set the appropriate timer. */
2906 fprintf (stderr
, "Reading summaries\n");
2908 /* Read the IPA summary data. */
2910 ipa_read_optimization_summaries ();
2912 ipa_read_summaries ();
2914 for (i
= 0; all_file_decl_data
[i
]; i
++)
2916 gcc_assert (all_file_decl_data
[i
]->symtab_node_encoder
);
2917 lto_symtab_encoder_delete (all_file_decl_data
[i
]->symtab_node_encoder
);
2918 all_file_decl_data
[i
]->symtab_node_encoder
= NULL
;
2919 lto_free_function_in_decl_state (all_file_decl_data
[i
]->global_decl_state
);
2920 all_file_decl_data
[i
]->global_decl_state
= NULL
;
2921 all_file_decl_data
[i
]->current_decl_state
= NULL
;
2924 /* Finally merge the cgraph according to the decl merging decisions. */
2925 timevar_push (TV_IPA_LTO_CGRAPH_MERGE
);
2926 if (symtab
->dump_file
)
2928 fprintf (symtab
->dump_file
, "Before merging:\n");
2929 symtab_node::dump_table (symtab
->dump_file
);
2933 lto_symtab_merge_symbols ();
2934 /* Removal of unreachable symbols is needed to make verify_symtab to pass;
2935 we are still having duplicated comdat groups containing local statics.
2936 We could also just remove them while merging. */
2937 symtab
->remove_unreachable_nodes (dump_file
);
2940 symtab
->state
= IPA_SSA
;
2941 /* FIXME: Technically all node removals happening here are useless, because
2942 WPA should not stream them. */
2944 symtab
->remove_unreachable_nodes (dump_file
);
2946 timevar_pop (TV_IPA_LTO_CGRAPH_MERGE
);
2948 /* Indicate that the cgraph is built and ready. */
2949 symtab
->function_flags_ready
= true;
2951 ggc_free (all_file_decl_data
);
2952 all_file_decl_data
= NULL
;
2956 /* Materialize all the bodies for all the nodes in the callgraph. */
2959 materialize_cgraph (void)
2961 struct cgraph_node
*node
;
2962 timevar_id_t lto_timer
;
2966 flag_wpa
? "Materializing decls:" : "Reading function bodies:");
2969 FOR_EACH_FUNCTION (node
)
2971 if (node
->lto_file_data
)
2973 lto_materialize_function (node
);
2974 lto_stats
.num_input_cgraph_nodes
++;
2979 /* Start the appropriate timer depending on the mode that we are
2981 lto_timer
= (flag_wpa
) ? TV_WHOPR_WPA
2982 : (flag_ltrans
) ? TV_WHOPR_LTRANS
2984 timevar_push (lto_timer
);
2986 current_function_decl
= NULL
;
2990 fprintf (stderr
, "\n");
2992 timevar_pop (lto_timer
);
2996 /* Show various memory usage statistics related to LTO. */
2998 print_lto_report_1 (void)
3000 const char *pfx
= (flag_lto
) ? "LTO" : (flag_wpa
) ? "WPA" : "LTRANS";
3001 fprintf (stderr
, "%s statistics\n", pfx
);
3003 fprintf (stderr
, "[%s] read %lu SCCs of average size %f\n",
3004 pfx
, num_sccs_read
, total_scc_size
/ (double)num_sccs_read
);
3005 fprintf (stderr
, "[%s] %lu tree bodies read in total\n", pfx
, total_scc_size
);
3006 if (flag_wpa
&& tree_scc_hash
)
3008 fprintf (stderr
, "[%s] tree SCC table: size %ld, %ld elements, "
3009 "collision ratio: %f\n", pfx
,
3010 (long) tree_scc_hash
->size (),
3011 (long) tree_scc_hash
->elements (),
3012 tree_scc_hash
->collisions ());
3013 hash_table
<tree_scc_hasher
>::iterator hiter
;
3014 tree_scc
*scc
, *max_scc
= NULL
;
3015 unsigned max_length
= 0;
3016 FOR_EACH_HASH_TABLE_ELEMENT (*tree_scc_hash
, scc
, x
, hiter
)
3018 unsigned length
= 0;
3020 for (; s
; s
= s
->next
)
3022 if (length
> max_length
)
3024 max_length
= length
;
3028 fprintf (stderr
, "[%s] tree SCC max chain length %u (size %u)\n",
3029 pfx
, max_length
, max_scc
->len
);
3030 fprintf (stderr
, "[%s] Compared %lu SCCs, %lu collisions (%f)\n", pfx
,
3031 num_scc_compares
, num_scc_compare_collisions
,
3032 num_scc_compare_collisions
/ (double) num_scc_compares
);
3033 fprintf (stderr
, "[%s] Merged %lu SCCs\n", pfx
, num_sccs_merged
);
3034 fprintf (stderr
, "[%s] Merged %lu tree bodies\n", pfx
,
3035 total_scc_size_merged
);
3036 fprintf (stderr
, "[%s] Merged %lu types\n", pfx
, num_merged_types
);
3037 fprintf (stderr
, "[%s] %lu types prevailed (%lu associated trees)\n",
3038 pfx
, num_prevailing_types
, num_type_scc_trees
);
3039 fprintf (stderr
, "[%s] GIMPLE canonical type table: size %ld, "
3040 "%ld elements, %ld searches, %ld collisions (ratio: %f)\n", pfx
,
3041 (long) htab_size (gimple_canonical_types
),
3042 (long) htab_elements (gimple_canonical_types
),
3043 (long) gimple_canonical_types
->searches
,
3044 (long) gimple_canonical_types
->collisions
,
3045 htab_collisions (gimple_canonical_types
));
3046 fprintf (stderr
, "[%s] GIMPLE canonical type pointer-map: "
3047 "%lu elements, %ld searches\n", pfx
,
3048 num_canonical_type_hash_entries
,
3049 num_canonical_type_hash_queries
);
3052 print_lto_report (pfx
);
3055 /* Perform whole program analysis (WPA) on the callgraph and write out the
3056 optimization plan. */
3059 do_whole_program_analysis (void)
3063 lto_parallelism
= 1;
3065 /* TODO: jobserver communicatoin is not supported, yet. */
3066 if (!strcmp (flag_wpa
, "jobserver"))
3067 lto_parallelism
= -1;
3070 lto_parallelism
= atoi (flag_wpa
);
3071 if (lto_parallelism
<= 0)
3072 lto_parallelism
= 0;
3075 timevar_start (TV_PHASE_OPT_GEN
);
3077 /* Note that since we are in WPA mode, materialize_cgraph will not
3078 actually read in all the function bodies. It only materializes
3079 the decls and cgraph nodes so that analysis can be performed. */
3080 materialize_cgraph ();
3082 /* Reading in the cgraph uses different timers, start timing WPA now. */
3083 timevar_push (TV_WHOPR_WPA
);
3085 if (pre_ipa_mem_report
)
3087 fprintf (stderr
, "Memory consumption before IPA\n");
3088 dump_memory_report (false);
3091 symtab
->function_flags_ready
= true;
3093 if (symtab
->dump_file
)
3094 symtab_node::dump_table (symtab
->dump_file
);
3095 bitmap_obstack_initialize (NULL
);
3096 symtab
->state
= IPA_SSA
;
3098 execute_ipa_pass_list (g
->get_passes ()->all_regular_ipa_passes
);
3100 if (symtab
->dump_file
)
3102 fprintf (symtab
->dump_file
, "Optimized ");
3103 symtab_node::dump_table (symtab
->dump_file
);
3105 #ifdef ENABLE_CHECKING
3106 symtab_node::verify_symtab_nodes ();
3108 bitmap_obstack_release (NULL
);
3110 /* We are about to launch the final LTRANS phase, stop the WPA timer. */
3111 timevar_pop (TV_WHOPR_WPA
);
3113 timevar_push (TV_WHOPR_PARTITIONING
);
3114 if (flag_lto_partition
== LTO_PARTITION_1TO1
)
3116 else if (flag_lto_partition
== LTO_PARTITION_MAX
)
3118 else if (flag_lto_partition
== LTO_PARTITION_ONE
)
3119 lto_balanced_map (1);
3120 else if (flag_lto_partition
== LTO_PARTITION_BALANCED
)
3121 lto_balanced_map (PARAM_VALUE (PARAM_LTO_PARTITIONS
));
3125 /* Inline summaries are needed for balanced partitioning. Free them now so
3126 the memory can be used for streamer caches. */
3127 inline_free_summary ();
3129 /* AUX pointers are used by partitioning code to bookkeep number of
3130 partitions symbol is in. This is no longer needed. */
3131 FOR_EACH_SYMBOL (node
)
3134 lto_stats
.num_cgraph_partitions
+= ltrans_partitions
.length ();
3136 /* Find out statics that need to be promoted
3137 to globals with hidden visibility because they are accessed from multiple
3139 lto_promote_cross_file_statics ();
3140 timevar_pop (TV_WHOPR_PARTITIONING
);
3142 timevar_stop (TV_PHASE_OPT_GEN
);
3144 /* Collect a last time - in lto_wpa_write_files we may end up forking
3145 with the idea that this doesn't increase memory usage. So we
3146 absoultely do not want to collect after that. */
3149 timevar_start (TV_PHASE_STREAM_OUT
);
3152 fprintf (stderr
, "\nStreaming out");
3155 lto_wpa_write_files ();
3157 fprintf (stderr
, "\n");
3158 timevar_stop (TV_PHASE_STREAM_OUT
);
3160 if (post_ipa_mem_report
)
3162 fprintf (stderr
, "Memory consumption after IPA\n");
3163 dump_memory_report (false);
3166 /* Show the LTO report before launching LTRANS. */
3167 if (flag_lto_report
|| (flag_wpa
&& flag_lto_report_wpa
))
3168 print_lto_report_1 ();
3170 dump_memory_report (true);
3174 static GTY(()) tree lto_eh_personality_decl
;
3176 /* Return the LTO personality function decl. */
3179 lto_eh_personality (void)
3181 if (!lto_eh_personality_decl
)
3183 /* Use the first personality DECL for our personality if we don't
3184 support multiple ones. This ensures that we don't artificially
3185 create the need for them in a single-language program. */
3186 if (first_personality_decl
&& !dwarf2out_do_cfi_asm ())
3187 lto_eh_personality_decl
= first_personality_decl
;
3189 lto_eh_personality_decl
= lhd_gcc_personality ();
3192 return lto_eh_personality_decl
;
3195 /* Set the process name based on the LTO mode. */
3198 lto_process_name (void)
3201 setproctitle ("lto1-lto");
3203 setproctitle ("lto1-wpa");
3205 setproctitle ("lto1-ltrans");
3209 /* Initialize the LTO front end. */
3214 lto_process_name ();
3215 lto_streamer_hooks_init ();
3217 lto_set_in_hooks (NULL
, get_section_data
, free_section_data
);
3218 memset (<o_stats
, 0, sizeof (lto_stats
));
3219 bitmap_obstack_initialize (NULL
);
3220 gimple_register_cfg_hooks ();
3221 #ifndef ACCEL_COMPILER
3222 unsigned char *table
3223 = ggc_vec_alloc
<unsigned char> (MAX_MACHINE_MODE
);
3224 for (int m
= 0; m
< MAX_MACHINE_MODE
; m
++)
3226 lto_mode_identity_table
= table
;
3231 /* Main entry point for the GIMPLE front end. This front end has
3232 three main personalities:
3234 - LTO (-flto). All the object files on the command line are
3235 loaded in memory and processed as a single translation unit.
3236 This is the traditional link-time optimization behavior.
3238 - WPA (-fwpa). Only the callgraph and summary information for
3239 files in the command file are loaded. A single callgraph
3240 (without function bodies) is instantiated for the whole set of
3241 files. IPA passes are only allowed to analyze the call graph
3242 and make transformation decisions. The callgraph is
3243 partitioned, each partition is written to a new object file
3244 together with the transformation decisions.
3246 - LTRANS (-fltrans). Similar to -flto but it prevents the IPA
3247 summary files from running again. Since WPA computed summary
3248 information and decided what transformations to apply, LTRANS
3249 simply applies them. */
3254 /* LTO is called as a front end, even though it is not a front end.
3255 Because it is called as a front end, TV_PHASE_PARSING and
3256 TV_PARSE_GLOBAL are active, and we need to turn them off while
3257 doing LTO. Later we turn them back on so they are active up in
3259 timevar_pop (TV_PARSE_GLOBAL
);
3260 timevar_stop (TV_PHASE_PARSING
);
3262 timevar_start (TV_PHASE_SETUP
);
3264 /* Initialize the LTO front end. */
3267 timevar_stop (TV_PHASE_SETUP
);
3268 timevar_start (TV_PHASE_STREAM_IN
);
3270 /* Read all the symbols and call graph from all the files in the
3272 read_cgraph_and_symbols (num_in_fnames
, in_fnames
);
3274 timevar_stop (TV_PHASE_STREAM_IN
);
3278 /* If WPA is enabled analyze the whole call graph and create an
3279 optimization plan. Otherwise, read in all the function
3280 bodies and continue with optimization. */
3282 do_whole_program_analysis ();
3285 timevar_start (TV_PHASE_OPT_GEN
);
3287 materialize_cgraph ();
3289 lto_promote_statics_nonwpa ();
3291 /* Let the middle end know that we have read and merged all of
3295 timevar_stop (TV_PHASE_OPT_GEN
);
3297 /* FIXME lto, if the processes spawned by WPA fail, we miss
3298 the chance to print WPA's report, so WPA will call
3299 print_lto_report before launching LTRANS. If LTRANS was
3300 launched directly by the driver we would not need to do
3302 if (flag_lto_report
|| (flag_wpa
&& flag_lto_report_wpa
))
3303 print_lto_report_1 ();
3307 /* Here we make LTO pretend to be a parser. */
3308 timevar_start (TV_PHASE_PARSING
);
3309 timevar_push (TV_PARSE_GLOBAL
);
3312 #include "gt-lto-lto.h"