1 /* Top-level LTO routines.
2 Copyright 2009, 2010, 2011 Free Software Foundation, Inc.
3 Contributed by CodeSourcery, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
27 #include "tree-flow.h"
28 #include "diagnostic-core.h"
32 #include "tree-ssa-operands.h"
33 #include "tree-pass.h"
34 #include "langhooks.h"
37 #include "pointer-set.h"
45 #include "lto-streamer.h"
46 #include "tree-streamer.h"
47 #include "splay-tree.h"
49 #include "ipa-inline.h"
50 #include "ipa-utils.h"
52 static GTY(()) tree first_personality_decl
;
54 /* Returns a hash code for P. */
57 hash_name (const void *p
)
59 const struct lto_section_slot
*ds
= (const struct lto_section_slot
*) p
;
60 return (hashval_t
) htab_hash_string (ds
->name
);
64 /* Returns nonzero if P1 and P2 are equal. */
67 eq_name (const void *p1
, const void *p2
)
69 const struct lto_section_slot
*s1
=
70 (const struct lto_section_slot
*) p1
;
71 const struct lto_section_slot
*s2
=
72 (const struct lto_section_slot
*) p2
;
74 return strcmp (s1
->name
, s2
->name
) == 0;
77 /* Free lto_section_slot */
80 free_with_string (void *arg
)
82 struct lto_section_slot
*s
= (struct lto_section_slot
*)arg
;
84 free (CONST_CAST (char *, s
->name
));
88 /* Create section hash table */
91 lto_obj_create_section_hash_table (void)
93 return htab_create (37, hash_name
, eq_name
, free_with_string
);
96 /* Delete an allocated integer KEY in the splay tree. */
99 lto_splay_tree_delete_id (splay_tree_key key
)
104 /* Compare splay tree node ids A and B. */
107 lto_splay_tree_compare_ids (splay_tree_key a
, splay_tree_key b
)
109 unsigned HOST_WIDE_INT ai
;
110 unsigned HOST_WIDE_INT bi
;
112 ai
= *(unsigned HOST_WIDE_INT
*) a
;
113 bi
= *(unsigned HOST_WIDE_INT
*) b
;
122 /* Look up splay tree node by ID in splay tree T. */
124 static splay_tree_node
125 lto_splay_tree_lookup (splay_tree t
, unsigned HOST_WIDE_INT id
)
127 return splay_tree_lookup (t
, (splay_tree_key
) &id
);
130 /* Check if KEY has ID. */
133 lto_splay_tree_id_equal_p (splay_tree_key key
, unsigned HOST_WIDE_INT id
)
135 return *(unsigned HOST_WIDE_INT
*) key
== id
;
138 /* Insert a splay tree node into tree T with ID as key and FILE_DATA as value.
139 The ID is allocated separately because we need HOST_WIDE_INTs which may
140 be wider than a splay_tree_key. */
143 lto_splay_tree_insert (splay_tree t
, unsigned HOST_WIDE_INT id
,
144 struct lto_file_decl_data
*file_data
)
146 unsigned HOST_WIDE_INT
*idp
= XCNEW (unsigned HOST_WIDE_INT
);
148 splay_tree_insert (t
, (splay_tree_key
) idp
, (splay_tree_value
) file_data
);
151 /* Create a splay tree. */
154 lto_splay_tree_new (void)
156 return splay_tree_new (lto_splay_tree_compare_ids
,
157 lto_splay_tree_delete_id
,
161 /* Read the constructors and inits. */
164 lto_materialize_constructors_and_inits (struct lto_file_decl_data
* file_data
)
167 const char *data
= lto_get_section_data (file_data
,
168 LTO_section_static_initializer
,
170 lto_input_constructors_and_inits (file_data
, data
);
171 lto_free_section_data (file_data
, LTO_section_static_initializer
, NULL
,
175 /* Return true when NODE has a clone that is analyzed (i.e. we need
176 to load its body even if the node itself is not needed). */
179 has_analyzed_clone_p (struct cgraph_node
*node
)
181 struct cgraph_node
*orig
= node
;
190 else if (node
->next_sibling_clone
)
191 node
= node
->next_sibling_clone
;
194 while (node
!= orig
&& !node
->next_sibling_clone
)
195 node
= node
->clone_of
;
197 node
= node
->next_sibling_clone
;
203 /* Read the function body for the function associated with NODE. */
206 lto_materialize_function (struct cgraph_node
*node
)
209 struct lto_file_decl_data
*file_data
;
210 const char *data
, *name
;
214 /* Read in functions with body (analyzed nodes)
215 and also functions that are needed to produce virtual clones. */
216 if (cgraph_function_with_gimple_body_p (node
) || has_analyzed_clone_p (node
))
218 /* Clones and thunks don't need to be read. */
222 /* Load the function body only if not operating in WPA mode. In
223 WPA mode, the body of the function is not needed. */
226 file_data
= node
->local
.lto_file_data
;
227 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
229 /* We may have renamed the declaration, e.g., a static function. */
230 name
= lto_get_decl_name_mapping (file_data
, name
);
232 data
= lto_get_section_data (file_data
, LTO_section_function_body
,
235 fatal_error ("%s: section %s is missing",
236 file_data
->file_name
,
239 gcc_assert (DECL_STRUCT_FUNCTION (decl
) == NULL
);
241 allocate_struct_function (decl
, false);
242 announce_function (decl
);
243 lto_input_function_body (file_data
, decl
, data
);
244 if (DECL_FUNCTION_PERSONALITY (decl
) && !first_personality_decl
)
245 first_personality_decl
= DECL_FUNCTION_PERSONALITY (decl
);
246 lto_stats
.num_function_bodies
++;
247 lto_free_section_data (file_data
, LTO_section_function_body
, name
,
253 /* Let the middle end know about the function. */
254 rest_of_decl_compilation (decl
, 1, 0);
258 /* Decode the content of memory pointed to by DATA in the in decl
259 state object STATE. DATA_IN points to a data_in structure for
260 decoding. Return the address after the decoded object in the
263 static const uint32_t *
264 lto_read_in_decl_state (struct data_in
*data_in
, const uint32_t *data
,
265 struct lto_in_decl_state
*state
)
272 decl
= streamer_tree_cache_get (data_in
->reader_cache
, ix
);
273 if (TREE_CODE (decl
) != FUNCTION_DECL
)
275 gcc_assert (decl
== void_type_node
);
278 state
->fn_decl
= decl
;
280 for (i
= 0; i
< LTO_N_DECL_STREAMS
; i
++)
282 uint32_t size
= *data
++;
283 tree
*decls
= ggc_alloc_vec_tree (size
);
285 for (j
= 0; j
< size
; j
++)
286 decls
[j
] = streamer_tree_cache_get (data_in
->reader_cache
, data
[j
]);
288 state
->streams
[i
].size
= size
;
289 state
->streams
[i
].trees
= decls
;
296 /* A hashtable of trees that potentially refer to variables or functions
297 that must be replaced with their prevailing variant. */
298 static GTY((if_marked ("ggc_marked_p"), param_is (union tree_node
))) htab_t
301 /* Remember that T is a tree that (potentially) refers to a variable
302 or function decl that may be replaced with its prevailing variant. */
304 remember_with_vars (tree t
)
306 *(tree
*) htab_find_slot (tree_with_vars
, t
, INSERT
) = t
;
309 #define GIMPLE_REGISTER_TYPE(tt) \
310 (TREE_VISITED (tt) ? gimple_register_type (tt) : tt)
312 #define LTO_FIXUP_TREE(tt) \
318 (tt) = GIMPLE_REGISTER_TYPE (tt); \
319 if (VAR_OR_FUNCTION_DECL_P (tt) && TREE_PUBLIC (tt)) \
320 remember_with_vars (t); \
324 static void lto_fixup_types (tree
);
326 /* Fix up fields of a tree_typed T. */
329 lto_ft_typed (tree t
)
331 LTO_FIXUP_TREE (TREE_TYPE (t
));
334 /* Fix up fields of a tree_common T. */
337 lto_ft_common (tree t
)
340 LTO_FIXUP_TREE (TREE_CHAIN (t
));
343 /* Fix up fields of a decl_minimal T. */
346 lto_ft_decl_minimal (tree t
)
349 LTO_FIXUP_TREE (DECL_NAME (t
));
350 LTO_FIXUP_TREE (DECL_CONTEXT (t
));
353 /* Fix up fields of a decl_common T. */
356 lto_ft_decl_common (tree t
)
358 lto_ft_decl_minimal (t
);
359 LTO_FIXUP_TREE (DECL_SIZE (t
));
360 LTO_FIXUP_TREE (DECL_SIZE_UNIT (t
));
361 LTO_FIXUP_TREE (DECL_INITIAL (t
));
362 LTO_FIXUP_TREE (DECL_ATTRIBUTES (t
));
363 LTO_FIXUP_TREE (DECL_ABSTRACT_ORIGIN (t
));
366 /* Fix up fields of a decl_with_vis T. */
369 lto_ft_decl_with_vis (tree t
)
371 lto_ft_decl_common (t
);
373 /* Accessor macro has side-effects, use field-name here. */
374 LTO_FIXUP_TREE (t
->decl_with_vis
.assembler_name
);
375 LTO_FIXUP_TREE (DECL_SECTION_NAME (t
));
378 /* Fix up fields of a decl_non_common T. */
381 lto_ft_decl_non_common (tree t
)
383 lto_ft_decl_with_vis (t
);
384 LTO_FIXUP_TREE (DECL_ARGUMENT_FLD (t
));
385 LTO_FIXUP_TREE (DECL_RESULT_FLD (t
));
386 LTO_FIXUP_TREE (DECL_VINDEX (t
));
387 /* The C frontends may create exact duplicates for DECL_ORIGINAL_TYPE
388 like for 'typedef enum foo foo'. We have no way of avoiding to
389 merge them and dwarf2out.c cannot deal with this,
390 so fix this up by clearing DECL_ORIGINAL_TYPE in this case. */
391 if (TREE_CODE (t
) == TYPE_DECL
392 && DECL_ORIGINAL_TYPE (t
) == TREE_TYPE (t
))
393 DECL_ORIGINAL_TYPE (t
) = NULL_TREE
;
396 /* Fix up fields of a decl_non_common T. */
399 lto_ft_function (tree t
)
401 lto_ft_decl_non_common (t
);
402 LTO_FIXUP_TREE (DECL_FUNCTION_PERSONALITY (t
));
405 /* Fix up fields of a field_decl T. */
408 lto_ft_field_decl (tree t
)
410 lto_ft_decl_common (t
);
411 LTO_FIXUP_TREE (DECL_FIELD_OFFSET (t
));
412 LTO_FIXUP_TREE (DECL_BIT_FIELD_TYPE (t
));
413 LTO_FIXUP_TREE (DECL_QUALIFIER (t
));
414 LTO_FIXUP_TREE (DECL_FIELD_BIT_OFFSET (t
));
415 LTO_FIXUP_TREE (DECL_FCONTEXT (t
));
418 /* Fix up fields of a type T. */
424 LTO_FIXUP_TREE (TYPE_CACHED_VALUES (t
));
425 LTO_FIXUP_TREE (TYPE_SIZE (t
));
426 LTO_FIXUP_TREE (TYPE_SIZE_UNIT (t
));
427 LTO_FIXUP_TREE (TYPE_ATTRIBUTES (t
));
428 LTO_FIXUP_TREE (TYPE_NAME (t
));
430 /* Accessors are for derived node types only. */
431 if (!POINTER_TYPE_P (t
))
432 LTO_FIXUP_TREE (TYPE_MINVAL (t
));
433 LTO_FIXUP_TREE (TYPE_MAXVAL (t
));
435 /* Accessor is for derived node types only. */
436 LTO_FIXUP_TREE (t
->type_non_common
.binfo
);
438 LTO_FIXUP_TREE (TYPE_CONTEXT (t
));
441 /* Fix up fields of a BINFO T. */
444 lto_ft_binfo (tree t
)
446 unsigned HOST_WIDE_INT i
, n
;
447 tree base
, saved_base
;
450 LTO_FIXUP_TREE (BINFO_VTABLE (t
));
451 LTO_FIXUP_TREE (BINFO_OFFSET (t
));
452 LTO_FIXUP_TREE (BINFO_VIRTUALS (t
));
453 LTO_FIXUP_TREE (BINFO_VPTR_FIELD (t
));
454 n
= VEC_length (tree
, BINFO_BASE_ACCESSES (t
));
455 for (i
= 0; i
< n
; i
++)
457 saved_base
= base
= BINFO_BASE_ACCESS (t
, i
);
458 LTO_FIXUP_TREE (base
);
459 if (base
!= saved_base
)
460 VEC_replace (tree
, BINFO_BASE_ACCESSES (t
), i
, base
);
462 LTO_FIXUP_TREE (BINFO_INHERITANCE_CHAIN (t
));
463 LTO_FIXUP_TREE (BINFO_SUBVTT_INDEX (t
));
464 LTO_FIXUP_TREE (BINFO_VPTR_INDEX (t
));
465 n
= BINFO_N_BASE_BINFOS (t
);
466 for (i
= 0; i
< n
; i
++)
468 saved_base
= base
= BINFO_BASE_BINFO (t
, i
);
469 LTO_FIXUP_TREE (base
);
470 if (base
!= saved_base
)
471 VEC_replace (tree
, BINFO_BASE_BINFOS (t
), i
, base
);
475 /* Fix up fields of a CONSTRUCTOR T. */
478 lto_ft_constructor (tree t
)
480 unsigned HOST_WIDE_INT idx
;
486 VEC_iterate(constructor_elt
, CONSTRUCTOR_ELTS (t
), idx
, ce
);
489 LTO_FIXUP_TREE (ce
->index
);
490 LTO_FIXUP_TREE (ce
->value
);
494 /* Fix up fields of an expression tree T. */
501 for (i
= TREE_OPERAND_LENGTH (t
) - 1; i
>= 0; --i
)
502 LTO_FIXUP_TREE (TREE_OPERAND (t
, i
));
505 /* Given a tree T fixup fields of T by replacing types with their merged
506 variant and other entities by an equal entity from an earlier compilation
507 unit, or an entity being canonical in a different way. This includes
508 for instance integer or string constants. */
511 lto_fixup_types (tree t
)
513 switch (TREE_CODE (t
))
515 case IDENTIFIER_NODE
:
519 LTO_FIXUP_TREE (TREE_VALUE (t
));
520 LTO_FIXUP_TREE (TREE_PURPOSE (t
));
521 LTO_FIXUP_TREE (TREE_CHAIN (t
));
525 lto_ft_field_decl (t
);
533 lto_ft_decl_common (t
);
537 lto_ft_decl_with_vis (t
);
541 lto_ft_decl_non_common (t
);
552 case PLACEHOLDER_EXPR
:
557 case TRANSLATION_UNIT_DECL
:
558 case OPTIMIZATION_NODE
:
559 case TARGET_OPTION_NODE
:
565 else if (TREE_CODE (t
) == CONSTRUCTOR
)
566 lto_ft_constructor (t
);
567 else if (CONSTANT_CLASS_P (t
))
568 LTO_FIXUP_TREE (TREE_TYPE (t
));
575 remember_with_vars (t
);
581 /* Return the resolution for the decl with index INDEX from DATA_IN. */
583 static enum ld_plugin_symbol_resolution
584 get_resolution (struct data_in
*data_in
, unsigned index
)
586 if (data_in
->globals_resolution
)
588 ld_plugin_symbol_resolution_t ret
;
589 /* We can have references to not emitted functions in
590 DECL_FUNCTION_PERSONALITY at least. So we can and have
591 to indeed return LDPR_UNKNOWN in some cases. */
592 if (VEC_length (ld_plugin_symbol_resolution_t
,
593 data_in
->globals_resolution
) <= index
)
595 ret
= VEC_index (ld_plugin_symbol_resolution_t
,
596 data_in
->globals_resolution
,
601 /* Delay resolution finding until decl merging. */
606 /* Register DECL with the global symbol table and change its
607 name if necessary to avoid name clashes for static globals across
611 lto_register_var_decl_in_symtab (struct data_in
*data_in
, tree decl
)
615 /* Variable has file scope, not local. Need to ensure static variables
616 between different files don't clash unexpectedly. */
617 if (!TREE_PUBLIC (decl
)
618 && !((context
= decl_function_context (decl
))
619 && auto_var_in_fn_p (decl
, context
)))
621 /* ??? We normally pre-mangle names before we serialize them
622 out. Here, in lto1, we do not know the language, and
623 thus cannot do the mangling again. Instead, we just
624 append a suffix to the mangled name. The resulting name,
625 however, is not a properly-formed mangled name, and will
626 confuse any attempt to unmangle it. */
627 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
630 ASM_FORMAT_PRIVATE_NAME (label
, name
, DECL_UID (decl
));
631 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (label
));
632 rest_of_decl_compilation (decl
, 1, 0);
633 VEC_safe_push (tree
, gc
, lto_global_var_decls
, decl
);
636 /* If this variable has already been declared, queue the
637 declaration for merging. */
638 if (TREE_PUBLIC (decl
))
641 if (!streamer_tree_cache_lookup (data_in
->reader_cache
, decl
, &ix
))
643 lto_symtab_register_decl (decl
, get_resolution (data_in
, ix
),
649 /* Register DECL with the global symbol table and change its
650 name if necessary to avoid name clashes for static globals across
651 different files. DATA_IN contains descriptors and tables for the
655 lto_register_function_decl_in_symtab (struct data_in
*data_in
, tree decl
)
657 /* Need to ensure static entities between different files
658 don't clash unexpectedly. */
659 if (!TREE_PUBLIC (decl
))
661 /* We must not use the DECL_ASSEMBLER_NAME macro here, as it
662 may set the assembler name where it was previously empty. */
663 tree old_assembler_name
= decl
->decl_with_vis
.assembler_name
;
665 /* FIXME lto: We normally pre-mangle names before we serialize
666 them out. Here, in lto1, we do not know the language, and
667 thus cannot do the mangling again. Instead, we just append a
668 suffix to the mangled name. The resulting name, however, is
669 not a properly-formed mangled name, and will confuse any
670 attempt to unmangle it. */
671 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
674 ASM_FORMAT_PRIVATE_NAME (label
, name
, DECL_UID (decl
));
675 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (label
));
677 /* We may arrive here with the old assembler name not set
678 if the function body is not needed, e.g., it has been
679 inlined away and does not appear in the cgraph. */
680 if (old_assembler_name
)
682 tree new_assembler_name
= DECL_ASSEMBLER_NAME (decl
);
684 /* Make the original assembler name available for later use.
685 We may have used it to indicate the section within its
686 object file where the function body may be found.
687 FIXME lto: Find a better way to maintain the function decl
688 to body section mapping so we don't need this hack. */
689 lto_record_renamed_decl (data_in
->file_data
,
690 IDENTIFIER_POINTER (old_assembler_name
),
691 IDENTIFIER_POINTER (new_assembler_name
));
695 /* If this variable has already been declared, queue the
696 declaration for merging. */
697 if (TREE_PUBLIC (decl
) && !DECL_ABSTRACT (decl
))
700 if (!streamer_tree_cache_lookup (data_in
->reader_cache
, decl
, &ix
))
702 lto_symtab_register_decl (decl
, get_resolution (data_in
, ix
),
708 /* Given a streamer cache structure DATA_IN (holding a sequence of trees
709 for one compilation unit) go over all trees starting at index FROM until the
710 end of the sequence and replace fields of those trees, and the trees
711 themself with their canonical variants as per gimple_register_type. */
714 uniquify_nodes (struct data_in
*data_in
, unsigned from
)
716 struct streamer_tree_cache_d
*cache
= data_in
->reader_cache
;
717 unsigned len
= VEC_length (tree
, cache
->nodes
);
720 /* Go backwards because children streamed for the first time come
721 as part of their parents, and hence are created after them. */
723 /* First register all the types in the cache. This makes sure to
724 have the original structure in the type cycles when registering
725 them and computing hashes. */
726 for (i
= len
; i
-- > from
;)
728 tree t
= VEC_index (tree
, cache
->nodes
, i
);
731 tree newt
= gimple_register_type (t
);
732 /* Mark non-prevailing types so we fix them up. No need
733 to reset that flag afterwards - nothing that refers
734 to those types is left and they are collected. */
736 TREE_VISITED (t
) = 1;
740 /* Second fixup all trees in the new cache entries. */
741 for (i
= len
; i
-- > from
;)
743 tree t
= VEC_index (tree
, cache
->nodes
, i
);
748 /* First fixup the fields of T. */
754 /* Now try to find a canonical variant of T itself. */
755 t
= GIMPLE_REGISTER_TYPE (t
);
759 /* The following re-creates proper variant lists while fixing up
760 the variant leaders. We do not stream TYPE_NEXT_VARIANT so the
761 variant list state before fixup is broken. */
764 /* Remove us from our main variant list if we are not the
766 if (TYPE_MAIN_VARIANT (t
) != t
)
768 tem
= TYPE_MAIN_VARIANT (t
);
769 while (tem
&& TYPE_NEXT_VARIANT (tem
) != t
)
770 tem
= TYPE_NEXT_VARIANT (tem
);
772 TYPE_NEXT_VARIANT (tem
) = TYPE_NEXT_VARIANT (t
);
773 TYPE_NEXT_VARIANT (t
) = NULL_TREE
;
776 /* Query our new main variant. */
777 mv
= GIMPLE_REGISTER_TYPE (TYPE_MAIN_VARIANT (t
));
779 /* If we were the variant leader and we get replaced ourselves drop
780 all variants from our list. */
781 if (TYPE_MAIN_VARIANT (t
) == t
787 tree tem2
= TYPE_NEXT_VARIANT (tem
);
788 TYPE_NEXT_VARIANT (tem
) = NULL_TREE
;
793 /* If we are not our own variant leader link us into our new leaders
797 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (mv
);
798 TYPE_NEXT_VARIANT (mv
) = t
;
799 if (RECORD_OR_UNION_TYPE_P (t
))
800 TYPE_BINFO (t
) = TYPE_BINFO (mv
);
803 /* Finally adjust our main variant and fix it up. */
804 TYPE_MAIN_VARIANT (t
) = mv
;
806 /* The following reconstructs the pointer chains
807 of the new pointed-to type if we are a main variant. We do
808 not stream those so they are broken before fixup. */
809 if (TREE_CODE (t
) == POINTER_TYPE
810 && TYPE_MAIN_VARIANT (t
) == t
)
812 TYPE_NEXT_PTR_TO (t
) = TYPE_POINTER_TO (TREE_TYPE (t
));
813 TYPE_POINTER_TO (TREE_TYPE (t
)) = t
;
815 else if (TREE_CODE (t
) == REFERENCE_TYPE
816 && TYPE_MAIN_VARIANT (t
) == t
)
818 TYPE_NEXT_REF_TO (t
) = TYPE_REFERENCE_TO (TREE_TYPE (t
));
819 TYPE_REFERENCE_TO (TREE_TYPE (t
)) = t
;
825 if (RECORD_OR_UNION_TYPE_P (t
))
828 if (TYPE_FIELDS (t
) != TYPE_FIELDS (oldt
))
829 for (f1
= TYPE_FIELDS (t
), f2
= TYPE_FIELDS (oldt
);
830 f1
&& f2
; f1
= TREE_CHAIN (f1
), f2
= TREE_CHAIN (f2
))
833 gcc_assert (f1
!= f2
&& DECL_NAME (f1
) == DECL_NAME (f2
));
834 if (!streamer_tree_cache_lookup (cache
, f2
, &ix
))
836 /* If we're going to replace an element which we'd
837 still visit in the next iterations, we wouldn't
838 handle it, so do it here. We do have to handle it
839 even though the field_decl itself will be removed,
840 as it could refer to e.g. integer_cst which we
841 wouldn't reach via any other way, hence they
842 (and their type) would stay uncollected. */
843 /* ??? We should rather make sure to replace all
844 references to f2 with f1. That means handling
845 COMPONENT_REFs and CONSTRUCTOR elements in
846 lto_fixup_types and special-case the field-decl
849 lto_fixup_types (f2
);
850 streamer_tree_cache_insert_at (cache
, f1
, ix
);
854 /* If we found a tree that is equal to oldt replace it in the
855 cache, so that further users (in the various LTO sections)
857 streamer_tree_cache_insert_at (cache
, t
, i
);
861 /* Finally compute the canonical type of all TREE_TYPEs and register
862 VAR_DECL and FUNCTION_DECL nodes in the symbol table.
863 From this point there are no longer any types with
864 TYPE_STRUCTURAL_EQUALITY_P and its type-based alias problems.
865 This step requires the TYPE_POINTER_TO lists being present, so
866 make sure it is done last. */
867 for (i
= len
; i
-- > from
;)
869 tree t
= VEC_index (tree
, cache
->nodes
, i
);
873 if (TREE_CODE (t
) == VAR_DECL
)
874 lto_register_var_decl_in_symtab (data_in
, t
);
875 else if (TREE_CODE (t
) == FUNCTION_DECL
&& !DECL_BUILT_IN (t
))
876 lto_register_function_decl_in_symtab (data_in
, t
);
878 && TREE_CODE (t
) == TYPE_DECL
)
879 debug_hooks
->type_decl (t
, !DECL_FILE_SCOPE_P (t
));
880 else if (TYPE_P (t
) && !TYPE_CANONICAL (t
))
881 TYPE_CANONICAL (t
) = gimple_register_canonical_type (t
);
886 /* Read all the symbols from buffer DATA, using descriptors in DECL_DATA.
887 RESOLUTIONS is the set of symbols picked by the linker (read from the
888 resolution file when the linker plugin is being used). */
891 lto_read_decls (struct lto_file_decl_data
*decl_data
, const void *data
,
892 VEC(ld_plugin_symbol_resolution_t
,heap
) *resolutions
)
894 const struct lto_decl_header
*header
= (const struct lto_decl_header
*) data
;
895 const int decl_offset
= sizeof (struct lto_decl_header
);
896 const int main_offset
= decl_offset
+ header
->decl_state_size
;
897 const int string_offset
= main_offset
+ header
->main_size
;
898 struct lto_input_block ib_main
;
899 struct data_in
*data_in
;
901 const uint32_t *data_ptr
, *data_end
;
902 uint32_t num_decl_states
;
904 LTO_INIT_INPUT_BLOCK (ib_main
, (const char *) data
+ main_offset
, 0,
907 data_in
= lto_data_in_create (decl_data
, (const char *) data
+ string_offset
,
908 header
->string_size
, resolutions
);
910 /* We do not uniquify the pre-loaded cache entries, those are middle-end
911 internal types that should not be merged. */
913 /* Read the global declarations and types. */
914 while (ib_main
.p
< ib_main
.len
)
917 unsigned from
= VEC_length (tree
, data_in
->reader_cache
->nodes
);
918 t
= stream_read_tree (&ib_main
, data_in
);
919 gcc_assert (t
&& ib_main
.p
<= ib_main
.len
);
920 uniquify_nodes (data_in
, from
);
923 /* Read in lto_in_decl_state objects. */
924 data_ptr
= (const uint32_t *) ((const char*) data
+ decl_offset
);
926 (const uint32_t *) ((const char*) data_ptr
+ header
->decl_state_size
);
927 num_decl_states
= *data_ptr
++;
929 gcc_assert (num_decl_states
> 0);
930 decl_data
->global_decl_state
= lto_new_in_decl_state ();
931 data_ptr
= lto_read_in_decl_state (data_in
, data_ptr
,
932 decl_data
->global_decl_state
);
934 /* Read in per-function decl states and enter them in hash table. */
935 decl_data
->function_decl_states
=
936 htab_create_ggc (37, lto_hash_in_decl_state
, lto_eq_in_decl_state
, NULL
);
938 for (i
= 1; i
< num_decl_states
; i
++)
940 struct lto_in_decl_state
*state
= lto_new_in_decl_state ();
943 data_ptr
= lto_read_in_decl_state (data_in
, data_ptr
, state
);
944 slot
= htab_find_slot (decl_data
->function_decl_states
, state
, INSERT
);
945 gcc_assert (*slot
== NULL
);
949 if (data_ptr
!= data_end
)
950 internal_error ("bytecode stream: garbage at the end of symbols section");
952 /* Set the current decl state to be the global state. */
953 decl_data
->current_decl_state
= decl_data
->global_decl_state
;
955 lto_data_in_delete (data_in
);
958 /* Custom version of strtoll, which is not portable. */
960 static HOST_WIDEST_INT
961 lto_parse_hex (const char *p
)
963 HOST_WIDEST_INT ret
= 0;
965 for (; *p
!= '\0'; ++p
)
970 if (c
>= '0' && c
<= '9')
972 else if (c
>= 'a' && c
<= 'f')
974 else if (c
>= 'A' && c
<= 'F')
977 internal_error ("could not parse hex number");
984 /* Read resolution for file named FILE_NAME. The resolution is read from
988 lto_resolution_read (splay_tree file_ids
, FILE *resolution
, lto_file
*file
)
990 /* We require that objects in the resolution file are in the same
991 order as the lto1 command line. */
992 unsigned int name_len
;
994 unsigned int num_symbols
;
996 struct lto_file_decl_data
*file_data
;
997 unsigned max_index
= 0;
998 splay_tree_node nd
= NULL
;
1003 name_len
= strlen (file
->filename
);
1004 obj_name
= XNEWVEC (char, name_len
+ 1);
1005 fscanf (resolution
, " "); /* Read white space. */
1007 fread (obj_name
, sizeof (char), name_len
, resolution
);
1008 obj_name
[name_len
] = '\0';
1009 if (filename_cmp (obj_name
, file
->filename
) != 0)
1010 internal_error ("unexpected file name %s in linker resolution file. "
1011 "Expected %s", obj_name
, file
->filename
);
1012 if (file
->offset
!= 0)
1016 HOST_WIDEST_INT offset
;
1017 t
= fscanf (resolution
, "@0x%16s", offset_p
);
1019 internal_error ("could not parse file offset");
1020 offset
= lto_parse_hex (offset_p
);
1021 if (offset
!= file
->offset
)
1022 internal_error ("unexpected offset");
1027 fscanf (resolution
, "%u", &num_symbols
);
1029 for (i
= 0; i
< num_symbols
; i
++)
1033 unsigned HOST_WIDE_INT id
;
1035 enum ld_plugin_symbol_resolution r
= (enum ld_plugin_symbol_resolution
) 0;
1037 unsigned int lto_resolution_str_len
=
1038 sizeof (lto_resolution_str
) / sizeof (char *);
1040 t
= fscanf (resolution
, "%u " HOST_WIDE_INT_PRINT_HEX_PURE
" %26s %*[^\n]\n",
1041 &index
, &id
, r_str
);
1043 internal_error ("invalid line in the resolution file");
1044 if (index
> max_index
)
1047 for (j
= 0; j
< lto_resolution_str_len
; j
++)
1049 if (strcmp (lto_resolution_str
[j
], r_str
) == 0)
1051 r
= (enum ld_plugin_symbol_resolution
) j
;
1055 if (j
== lto_resolution_str_len
)
1056 internal_error ("invalid resolution in the resolution file");
1058 if (!(nd
&& lto_splay_tree_id_equal_p (nd
->key
, id
)))
1060 nd
= lto_splay_tree_lookup (file_ids
, id
);
1062 internal_error ("resolution sub id " HOST_WIDE_INT_PRINT_HEX_PURE
1063 " not in object file", id
);
1066 file_data
= (struct lto_file_decl_data
*)nd
->value
;
1067 VEC_safe_grow_cleared (ld_plugin_symbol_resolution_t
, heap
,
1068 file_data
->resolutions
,
1070 VEC_replace (ld_plugin_symbol_resolution_t
,
1071 file_data
->resolutions
, index
, r
);
1075 /* List of file_decl_datas */
1076 struct file_data_list
1078 struct lto_file_decl_data
*first
, *last
;
1081 /* Is the name for a id'ed LTO section? */
1084 lto_section_with_id (const char *name
, unsigned HOST_WIDE_INT
*id
)
1088 if (strncmp (name
, LTO_SECTION_NAME_PREFIX
, strlen (LTO_SECTION_NAME_PREFIX
)))
1090 s
= strrchr (name
, '.');
1091 return s
&& sscanf (s
, "." HOST_WIDE_INT_PRINT_HEX_PURE
, id
) == 1;
1094 /* Create file_data of each sub file id */
1097 create_subid_section_table (struct lto_section_slot
*ls
, splay_tree file_ids
,
1098 struct file_data_list
*list
)
1100 struct lto_section_slot s_slot
, *new_slot
;
1101 unsigned HOST_WIDE_INT id
;
1105 struct lto_file_decl_data
*file_data
;
1107 if (!lto_section_with_id (ls
->name
, &id
))
1110 /* Find hash table of sub module id */
1111 nd
= lto_splay_tree_lookup (file_ids
, id
);
1114 file_data
= (struct lto_file_decl_data
*)nd
->value
;
1118 file_data
= ggc_alloc_lto_file_decl_data ();
1119 memset(file_data
, 0, sizeof (struct lto_file_decl_data
));
1121 file_data
->section_hash_table
= lto_obj_create_section_hash_table ();;
1122 lto_splay_tree_insert (file_ids
, id
, file_data
);
1124 /* Maintain list in linker order */
1126 list
->first
= file_data
;
1128 list
->last
->next
= file_data
;
1129 list
->last
= file_data
;
1132 /* Copy section into sub module hash table */
1133 new_name
= XDUPVEC (char, ls
->name
, strlen (ls
->name
) + 1);
1134 s_slot
.name
= new_name
;
1135 hash_slot
= htab_find_slot (file_data
->section_hash_table
, &s_slot
, INSERT
);
1136 gcc_assert (*hash_slot
== NULL
);
1138 new_slot
= XDUP (struct lto_section_slot
, ls
);
1139 new_slot
->name
= new_name
;
1140 *hash_slot
= new_slot
;
1144 /* Read declarations and other initializations for a FILE_DATA. */
1147 lto_file_finalize (struct lto_file_decl_data
*file_data
, lto_file
*file
)
1152 file_data
->renaming_hash_table
= lto_create_renaming_table ();
1153 file_data
->file_name
= file
->filename
;
1154 data
= lto_get_section_data (file_data
, LTO_section_decls
, NULL
, &len
);
1157 internal_error ("cannot read LTO decls from %s", file_data
->file_name
);
1160 lto_read_decls (file_data
, data
, file_data
->resolutions
);
1161 lto_free_section_data (file_data
, LTO_section_decls
, NULL
, data
, len
);
1164 /* Finalize FILE_DATA in FILE and increase COUNT. */
1167 lto_create_files_from_ids (lto_file
*file
, struct lto_file_decl_data
*file_data
,
1170 lto_file_finalize (file_data
, file
);
1171 if (cgraph_dump_file
)
1172 fprintf (cgraph_dump_file
, "Creating file %s with sub id " HOST_WIDE_INT_PRINT_HEX
"\n",
1173 file_data
->file_name
, file_data
->id
);
1178 /* Generate a TREE representation for all types and external decls
1181 Read all of the globals out of the file. Then read the cgraph
1182 and process the .o index into the cgraph nodes so that it can open
1183 the .o file to load the functions and ipa information. */
1185 static struct lto_file_decl_data
*
1186 lto_file_read (lto_file
*file
, FILE *resolution_file
, int *count
)
1188 struct lto_file_decl_data
*file_data
= NULL
;
1189 splay_tree file_ids
;
1190 htab_t section_hash_table
;
1191 struct lto_section_slot
*section
;
1192 struct file_data_list file_list
;
1193 struct lto_section_list section_list
;
1195 memset (§ion_list
, 0, sizeof (struct lto_section_list
));
1196 section_hash_table
= lto_obj_build_section_table (file
, §ion_list
);
1198 /* Find all sub modules in the object and put their sections into new hash
1199 tables in a splay tree. */
1200 file_ids
= lto_splay_tree_new ();
1201 memset (&file_list
, 0, sizeof (struct file_data_list
));
1202 for (section
= section_list
.first
; section
!= NULL
; section
= section
->next
)
1203 create_subid_section_table (section
, file_ids
, &file_list
);
1205 /* Add resolutions to file ids */
1206 lto_resolution_read (file_ids
, resolution_file
, file
);
1208 /* Finalize each lto file for each submodule in the merged object */
1209 for (file_data
= file_list
.first
; file_data
!= NULL
; file_data
= file_data
->next
)
1210 lto_create_files_from_ids (file
, file_data
, count
);
1212 splay_tree_delete (file_ids
);
1213 htab_delete (section_hash_table
);
1215 return file_list
.first
;
1218 #if HAVE_MMAP_FILE && HAVE_SYSCONF && defined _SC_PAGE_SIZE
1219 #define LTO_MMAP_IO 1
1223 /* Page size of machine is used for mmap and munmap calls. */
1224 static size_t page_mask
;
1227 /* Get the section data of length LEN from FILENAME starting at
1228 OFFSET. The data segment must be freed by the caller when the
1229 caller is finished. Returns NULL if all was not well. */
1232 lto_read_section_data (struct lto_file_decl_data
*file_data
,
1233 intptr_t offset
, size_t len
)
1237 static char *fd_name
;
1239 intptr_t computed_len
;
1240 intptr_t computed_offset
;
1244 /* Keep a single-entry file-descriptor cache. The last file we
1245 touched will get closed at exit.
1246 ??? Eventually we want to add a more sophisticated larger cache
1247 or rather fix function body streaming to not stream them in
1248 practically random order. */
1250 && filename_cmp (fd_name
, file_data
->file_name
) != 0)
1258 fd
= open (file_data
->file_name
, O_RDONLY
|O_BINARY
);
1261 fatal_error ("Cannot open %s", file_data
->file_name
);
1264 fd_name
= xstrdup (file_data
->file_name
);
1270 size_t page_size
= sysconf (_SC_PAGE_SIZE
);
1271 page_mask
= ~(page_size
- 1);
1274 computed_offset
= offset
& page_mask
;
1275 diff
= offset
- computed_offset
;
1276 computed_len
= len
+ diff
;
1278 result
= (char *) mmap (NULL
, computed_len
, PROT_READ
, MAP_PRIVATE
,
1279 fd
, computed_offset
);
1280 if (result
== MAP_FAILED
)
1282 fatal_error ("Cannot map %s", file_data
->file_name
);
1286 return result
+ diff
;
1288 result
= (char *) xmalloc (len
);
1289 if (lseek (fd
, offset
, SEEK_SET
) != offset
1290 || read (fd
, result
, len
) != (ssize_t
) len
)
1293 fatal_error ("Cannot read %s", file_data
->file_name
);
1297 /* Native windows doesn't supports delayed unlink on opened file. So
1298 we close file here again. This produces higher I/O load, but at least
1299 it prevents to have dangling file handles preventing unlink. */
1310 /* Get the section data from FILE_DATA of SECTION_TYPE with NAME.
1311 NAME will be NULL unless the section type is for a function
1315 get_section_data (struct lto_file_decl_data
*file_data
,
1316 enum lto_section_type section_type
,
1320 htab_t section_hash_table
= file_data
->section_hash_table
;
1321 struct lto_section_slot
*f_slot
;
1322 struct lto_section_slot s_slot
;
1323 const char *section_name
= lto_get_section_name (section_type
, name
, file_data
);
1327 s_slot
.name
= section_name
;
1328 f_slot
= (struct lto_section_slot
*) htab_find (section_hash_table
, &s_slot
);
1331 data
= lto_read_section_data (file_data
, f_slot
->start
, f_slot
->len
);
1335 free (CONST_CAST (char *, section_name
));
1340 /* Free the section data from FILE_DATA of SECTION_TYPE with NAME that
1341 starts at OFFSET and has LEN bytes. */
1344 free_section_data (struct lto_file_decl_data
*file_data ATTRIBUTE_UNUSED
,
1345 enum lto_section_type section_type ATTRIBUTE_UNUSED
,
1346 const char *name ATTRIBUTE_UNUSED
,
1347 const char *offset
, size_t len ATTRIBUTE_UNUSED
)
1350 intptr_t computed_len
;
1351 intptr_t computed_offset
;
1356 computed_offset
= ((intptr_t) offset
) & page_mask
;
1357 diff
= (intptr_t) offset
- computed_offset
;
1358 computed_len
= len
+ diff
;
1360 munmap ((caddr_t
) computed_offset
, computed_len
);
1362 free (CONST_CAST(char *, offset
));
1366 /* Structure describing ltrans partitions. */
1368 struct ltrans_partition_def
1370 cgraph_node_set cgraph_set
;
1371 varpool_node_set varpool_set
;
1376 typedef struct ltrans_partition_def
*ltrans_partition
;
1377 DEF_VEC_P(ltrans_partition
);
1378 DEF_VEC_ALLOC_P(ltrans_partition
,heap
);
1380 static VEC(ltrans_partition
, heap
) *ltrans_partitions
;
1382 static void add_cgraph_node_to_partition (ltrans_partition part
, struct cgraph_node
*node
);
1383 static void add_varpool_node_to_partition (ltrans_partition part
, struct varpool_node
*vnode
);
1385 /* Create new partition with name NAME. */
1386 static ltrans_partition
1387 new_partition (const char *name
)
1389 ltrans_partition part
= XCNEW (struct ltrans_partition_def
);
1390 part
->cgraph_set
= cgraph_node_set_new ();
1391 part
->varpool_set
= varpool_node_set_new ();
1394 VEC_safe_push (ltrans_partition
, heap
, ltrans_partitions
, part
);
1398 /* Free memory used by ltrans datastructures. */
1400 free_ltrans_partitions (void)
1403 ltrans_partition part
;
1404 for (idx
= 0; VEC_iterate (ltrans_partition
, ltrans_partitions
, idx
, part
); idx
++)
1406 free_cgraph_node_set (part
->cgraph_set
);
1409 VEC_free (ltrans_partition
, heap
, ltrans_partitions
);
1412 /* See all references that go to comdat objects and bring them into partition too.
1413 Also see all aliases of the newly added entry and bring them, too. */
1415 add_references_to_partition (ltrans_partition part
, struct ipa_ref_list
*refs
)
1418 struct ipa_ref
*ref
;
1419 for (i
= 0; ipa_ref_list_reference_iterate (refs
, i
, ref
); i
++)
1421 if (ref
->refered_type
== IPA_REF_CGRAPH
1422 && (DECL_COMDAT (cgraph_function_node (ipa_ref_node (ref
),
1424 || (ref
->use
== IPA_REF_ALIAS
1426 ("weakref", DECL_ATTRIBUTES (ipa_ref_node (ref
)->decl
))))
1427 && !cgraph_node_in_set_p (ipa_ref_node (ref
), part
->cgraph_set
))
1428 add_cgraph_node_to_partition (part
, ipa_ref_node (ref
));
1430 if (ref
->refered_type
== IPA_REF_VARPOOL
1431 && (DECL_COMDAT (ipa_ref_varpool_node (ref
)->decl
)
1432 || (ref
->use
== IPA_REF_ALIAS
1435 DECL_ATTRIBUTES (ipa_ref_varpool_node (ref
)->decl
))))
1436 && !varpool_node_in_set_p (ipa_ref_varpool_node (ref
),
1438 add_varpool_node_to_partition (part
, ipa_ref_varpool_node (ref
));
1440 for (i
= 0; ipa_ref_list_refering_iterate (refs
, i
, ref
); i
++)
1442 if (ref
->refering_type
== IPA_REF_CGRAPH
1443 && ref
->use
== IPA_REF_ALIAS
1444 && !cgraph_node_in_set_p (ipa_ref_refering_node (ref
),
1446 && !lookup_attribute ("weakref",
1448 (ipa_ref_refering_node (ref
)->decl
)))
1449 add_cgraph_node_to_partition (part
, ipa_ref_refering_node (ref
));
1451 if (ref
->refering_type
== IPA_REF_VARPOOL
1452 && ref
->use
== IPA_REF_ALIAS
1453 && !varpool_node_in_set_p (ipa_ref_refering_varpool_node (ref
),
1455 && !lookup_attribute ("weakref",
1457 (ipa_ref_refering_varpool_node (ref
)->decl
)))
1458 add_varpool_node_to_partition (part
,
1459 ipa_ref_refering_varpool_node (ref
));
1463 /* Worker for add_cgraph_node_to_partition. */
1466 add_cgraph_node_to_partition_1 (struct cgraph_node
*node
, void *data
)
1468 ltrans_partition part
= (ltrans_partition
) data
;
1470 /* non-COMDAT aliases of COMDAT functions needs to be output just once. */
1471 if (!DECL_COMDAT (node
->decl
)
1472 && !node
->global
.inlined_to
1475 gcc_assert (node
->thunk
.thunk_p
|| node
->alias
);
1481 node
->in_other_partition
= 1;
1482 if (cgraph_dump_file
)
1483 fprintf (cgraph_dump_file
, "Node %s/%i now used in multiple partitions\n",
1484 cgraph_node_name (node
), node
->uid
);
1486 node
->aux
= (void *)((size_t)node
->aux
+ 1);
1487 cgraph_node_set_add (part
->cgraph_set
, node
);
1491 /* Add NODE to partition as well as the inline callees and referred comdats into partition PART. */
1494 add_cgraph_node_to_partition (ltrans_partition part
, struct cgraph_node
*node
)
1496 struct cgraph_edge
*e
;
1497 cgraph_node_set_iterator csi
;
1498 struct cgraph_node
*n
;
1500 /* If NODE is already there, we have nothing to do. */
1501 csi
= cgraph_node_set_find (part
->cgraph_set
, node
);
1502 if (!csi_end_p (csi
))
1505 cgraph_for_node_thunks_and_aliases (node
, add_cgraph_node_to_partition_1
, part
, true);
1507 part
->insns
+= inline_summary (node
)->self_size
;
1510 cgraph_node_set_add (part
->cgraph_set
, node
);
1512 for (e
= node
->callees
; e
; e
= e
->next_callee
)
1513 if ((!e
->inline_failed
1514 || DECL_COMDAT (cgraph_function_node (e
->callee
, NULL
)->decl
))
1515 && !cgraph_node_in_set_p (e
->callee
, part
->cgraph_set
))
1516 add_cgraph_node_to_partition (part
, e
->callee
);
1518 /* The only way to assemble non-weakref alias is to add the aliased object into
1520 add_references_to_partition (part
, &node
->ref_list
);
1521 n
= cgraph_function_node (node
, NULL
);
1523 && !lookup_attribute ("weakref",
1524 DECL_ATTRIBUTES (node
->decl
)))
1525 add_cgraph_node_to_partition (part
, n
);
1527 if (node
->same_comdat_group
)
1528 for (n
= node
->same_comdat_group
; n
!= node
; n
= n
->same_comdat_group
)
1529 add_cgraph_node_to_partition (part
, n
);
1532 /* Add VNODE to partition as well as comdat references partition PART. */
1535 add_varpool_node_to_partition (ltrans_partition part
, struct varpool_node
*vnode
)
1537 varpool_node_set_iterator vsi
;
1538 struct varpool_node
*v
;
1540 /* If NODE is already there, we have nothing to do. */
1541 vsi
= varpool_node_set_find (part
->varpool_set
, vnode
);
1542 if (!vsi_end_p (vsi
))
1545 varpool_node_set_add (part
->varpool_set
, vnode
);
1549 vnode
->in_other_partition
= 1;
1550 if (cgraph_dump_file
)
1551 fprintf (cgraph_dump_file
, "Varpool node %s now used in multiple partitions\n",
1552 varpool_node_name (vnode
));
1554 vnode
->aux
= (void *)((size_t)vnode
->aux
+ 1);
1556 /* The only way to assemble non-weakref alias is to add the aliased object into
1558 v
= varpool_variable_node (vnode
, NULL
);
1560 && !lookup_attribute ("weakref",
1561 DECL_ATTRIBUTES (vnode
->decl
)))
1562 add_varpool_node_to_partition (part
, v
);
1564 add_references_to_partition (part
, &vnode
->ref_list
);
1566 if (vnode
->same_comdat_group
1567 && !varpool_node_in_set_p (vnode
->same_comdat_group
, part
->varpool_set
))
1568 add_varpool_node_to_partition (part
, vnode
->same_comdat_group
);
1571 /* Undo all additions until number of cgraph nodes in PARITION is N_CGRAPH_NODES
1572 and number of varpool nodes is N_VARPOOL_NODES. */
1575 undo_partition (ltrans_partition partition
, unsigned int n_cgraph_nodes
,
1576 unsigned int n_varpool_nodes
)
1578 while (VEC_length (cgraph_node_ptr
, partition
->cgraph_set
->nodes
) >
1581 struct cgraph_node
*node
= VEC_index (cgraph_node_ptr
,
1582 partition
->cgraph_set
->nodes
,
1584 partition
->insns
-= inline_summary (node
)->self_size
;
1585 cgraph_node_set_remove (partition
->cgraph_set
, node
);
1586 node
->aux
= (void *)((size_t)node
->aux
- 1);
1588 while (VEC_length (varpool_node_ptr
, partition
->varpool_set
->nodes
) >
1591 struct varpool_node
*node
= VEC_index (varpool_node_ptr
,
1592 partition
->varpool_set
->nodes
,
1594 varpool_node_set_remove (partition
->varpool_set
, node
);
1595 node
->aux
= (void *)((size_t)node
->aux
- 1);
1599 /* Return true if NODE should be partitioned.
1600 This means that partitioning algorithm should put NODE into one of partitions.
1601 This apply to most functions with bodies. Functions that are not partitions
1602 are put into every unit needing them. This is the case of i.e. COMDATs. */
1605 partition_cgraph_node_p (struct cgraph_node
*node
)
1607 /* We will get proper partition based on function they are inlined to. */
1608 if (node
->global
.inlined_to
)
1610 /* Nodes without a body do not need partitioning. */
1611 if (!node
->analyzed
)
1613 /* Extern inlines and comdat are always only in partitions they are needed. */
1614 if (DECL_EXTERNAL (node
->decl
)
1615 || (DECL_COMDAT (node
->decl
)
1616 && !cgraph_used_from_object_file_p (node
)))
1618 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (node
->decl
)))
1623 /* Return true if VNODE should be partitioned.
1624 This means that partitioning algorithm should put VNODE into one of partitions. */
1627 partition_varpool_node_p (struct varpool_node
*vnode
)
1629 if (vnode
->alias
|| !vnode
->needed
)
1631 /* Constant pool and comdat are always only in partitions they are needed. */
1632 if (DECL_IN_CONSTANT_POOL (vnode
->decl
)
1633 || (DECL_COMDAT (vnode
->decl
)
1634 && !vnode
->force_output
1635 && !varpool_used_from_object_file_p (vnode
)))
1637 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (vnode
->decl
)))
1642 /* Group cgrah nodes by input files. This is used mainly for testing
1646 lto_1_to_1_map (void)
1648 struct cgraph_node
*node
;
1649 struct varpool_node
*vnode
;
1650 struct lto_file_decl_data
*file_data
;
1651 struct pointer_map_t
*pmap
;
1652 ltrans_partition partition
;
1654 int npartitions
= 0;
1656 timevar_push (TV_WHOPR_WPA
);
1658 pmap
= pointer_map_create ();
1660 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1662 if (!partition_cgraph_node_p (node
)
1666 file_data
= node
->local
.lto_file_data
;
1670 slot
= pointer_map_contains (pmap
, file_data
);
1672 partition
= (ltrans_partition
) *slot
;
1675 partition
= new_partition (file_data
->file_name
);
1676 slot
= pointer_map_insert (pmap
, file_data
);
1682 && VEC_length (ltrans_partition
, ltrans_partitions
))
1683 partition
= VEC_index (ltrans_partition
, ltrans_partitions
, 0);
1686 partition
= new_partition ("");
1687 slot
= pointer_map_insert (pmap
, NULL
);
1692 add_cgraph_node_to_partition (partition
, node
);
1695 for (vnode
= varpool_nodes
; vnode
; vnode
= vnode
->next
)
1697 if (!partition_varpool_node_p (vnode
)
1700 file_data
= vnode
->lto_file_data
;
1701 slot
= pointer_map_contains (pmap
, file_data
);
1703 partition
= (ltrans_partition
) *slot
;
1706 partition
= new_partition (file_data
->file_name
);
1707 slot
= pointer_map_insert (pmap
, file_data
);
1712 add_varpool_node_to_partition (partition
, vnode
);
1714 for (node
= cgraph_nodes
; node
; node
= node
->next
)
1716 for (vnode
= varpool_nodes
; vnode
; vnode
= vnode
->next
)
1719 /* If the cgraph is empty, create one cgraph node set so that there is still
1720 an output file for any variables that need to be exported in a DSO. */
1722 new_partition ("empty");
1724 pointer_map_destroy (pmap
);
1726 timevar_pop (TV_WHOPR_WPA
);
1728 lto_stats
.num_cgraph_partitions
+= VEC_length (ltrans_partition
,
1732 /* Helper function for qsort; sort nodes by order. */
1734 node_cmp (const void *pa
, const void *pb
)
1736 const struct cgraph_node
*a
= *(const struct cgraph_node
* const *) pa
;
1737 const struct cgraph_node
*b
= *(const struct cgraph_node
* const *) pb
;
1738 return b
->order
- a
->order
;
1741 /* Helper function for qsort; sort nodes by order. */
1743 varpool_node_cmp (const void *pa
, const void *pb
)
1745 const struct varpool_node
*a
= *(const struct varpool_node
* const *) pa
;
1746 const struct varpool_node
*b
= *(const struct varpool_node
* const *) pb
;
1747 return b
->order
- a
->order
;
1750 /* Group cgraph nodes into equally-sized partitions.
1752 The partitioning algorithm is simple: nodes are taken in predefined order.
1753 The order corresponds to the order we want functions to have in the final
1754 output. In the future this will be given by function reordering pass, but
1755 at the moment we use the topological order, which is a good approximation.
1757 The goal is to partition this linear order into intervals (partitions) so
1758 that all the partitions have approximately the same size and the number of
1759 callgraph or IPA reference edges crossing boundaries is minimal.
1761 This is a lot faster (O(n) in size of callgraph) than algorithms doing
1762 priority-based graph clustering that are generally O(n^2) and, since
1763 WHOPR is designed to make things go well across partitions, it leads
1766 We compute the expected size of a partition as:
1768 max (total_size / lto_partitions, min_partition_size)
1770 We use dynamic expected size of partition so small programs are partitioned
1771 into enough partitions to allow use of multiple CPUs, while large programs
1772 are not partitioned too much. Creating too many partitions significantly
1773 increases the streaming overhead.
1775 In the future, we would like to bound the maximal size of partitions so as
1776 to prevent the LTRANS stage from consuming too much memory. At the moment,
1777 however, the WPA stage is the most memory intensive for large benchmarks,
1778 since too many types and declarations are read into memory.
1780 The function implements a simple greedy algorithm. Nodes are being added
1781 to the current partition until after 3/4 of the expected partition size is
1782 reached. Past this threshold, we keep track of boundary size (number of
1783 edges going to other partitions) and continue adding functions until after
1784 the current partition has grown to twice the expected partition size. Then
1785 the process is undone to the point where the minimal ratio of boundary size
1786 and in-partition calls was reached. */
1789 lto_balanced_map (void)
1792 int n_varpool_nodes
= 0, varpool_pos
= 0;
1793 struct cgraph_node
**postorder
=
1794 XCNEWVEC (struct cgraph_node
*, cgraph_n_nodes
);
1795 struct cgraph_node
**order
= XNEWVEC (struct cgraph_node
*, cgraph_max_uid
);
1796 struct varpool_node
**varpool_order
= NULL
;
1797 int i
, postorder_len
;
1798 struct cgraph_node
*node
;
1799 int total_size
= 0, best_total_size
= 0;
1801 ltrans_partition partition
;
1802 unsigned int last_visited_cgraph_node
= 0, last_visited_varpool_node
= 0;
1803 struct varpool_node
*vnode
;
1804 int cost
= 0, internal
= 0;
1805 int best_n_nodes
= 0, best_n_varpool_nodes
= 0, best_i
= 0, best_cost
=
1806 INT_MAX
, best_internal
= 0;
1808 int current_order
= -1;
1810 for (vnode
= varpool_nodes
; vnode
; vnode
= vnode
->next
)
1811 gcc_assert (!vnode
->aux
);
1812 /* Until we have better ordering facility, use toplogical order.
1813 Include only nodes we will partition and compute estimate of program
1814 size. Note that since nodes that are not partitioned might be put into
1815 multiple partitions, this is just an estimate of real size. This is why
1816 we keep partition_size updated after every partition is finalized. */
1817 postorder_len
= ipa_reverse_postorder (postorder
);
1819 for (i
= 0; i
< postorder_len
; i
++)
1821 node
= postorder
[i
];
1822 if (partition_cgraph_node_p (node
))
1824 order
[n_nodes
++] = node
;
1825 total_size
+= inline_summary (node
)->size
;
1830 if (!flag_toplevel_reorder
)
1832 qsort (order
, n_nodes
, sizeof (struct cgraph_node
*), node_cmp
);
1834 for (vnode
= varpool_nodes
; vnode
; vnode
= vnode
->next
)
1835 if (partition_varpool_node_p (vnode
))
1837 varpool_order
= XNEWVEC (struct varpool_node
*, n_varpool_nodes
);
1839 n_varpool_nodes
= 0;
1840 for (vnode
= varpool_nodes
; vnode
; vnode
= vnode
->next
)
1841 if (partition_varpool_node_p (vnode
))
1842 varpool_order
[n_varpool_nodes
++] = vnode
;
1843 qsort (varpool_order
, n_varpool_nodes
, sizeof (struct varpool_node
*),
1847 /* Compute partition size and create the first partition. */
1848 partition_size
= total_size
/ PARAM_VALUE (PARAM_LTO_PARTITIONS
);
1849 if (partition_size
< PARAM_VALUE (MIN_PARTITION_SIZE
))
1850 partition_size
= PARAM_VALUE (MIN_PARTITION_SIZE
);
1852 partition
= new_partition ("");
1853 if (cgraph_dump_file
)
1854 fprintf (cgraph_dump_file
, "Total unit size: %i, partition size: %i\n",
1855 total_size
, partition_size
);
1857 for (i
= 0; i
< n_nodes
; i
++)
1862 current_order
= order
[i
]->order
;
1864 if (!flag_toplevel_reorder
)
1865 while (varpool_pos
< n_varpool_nodes
&& varpool_order
[varpool_pos
]->order
< current_order
)
1867 if (!varpool_order
[varpool_pos
]->aux
)
1868 add_varpool_node_to_partition (partition
, varpool_order
[varpool_pos
]);
1872 add_cgraph_node_to_partition (partition
, order
[i
]);
1873 total_size
-= inline_summary (order
[i
])->size
;
1876 /* Once we added a new node to the partition, we also want to add
1877 all referenced variables unless they was already added into some
1879 add_cgraph_node_to_partition adds possibly multiple nodes and
1880 variables that are needed to satisfy needs of ORDER[i].
1881 We remember last visited cgraph and varpool node from last iteration
1882 of outer loop that allows us to process every new addition.
1884 At the same time we compute size of the boundary into COST. Every
1885 callgraph or IPA reference edge leaving the partition contributes into
1886 COST. Every edge inside partition was earlier computed as one leaving
1887 it and thus we need to subtract it from COST. */
1888 while (last_visited_cgraph_node
<
1889 VEC_length (cgraph_node_ptr
, partition
->cgraph_set
->nodes
)
1890 || last_visited_varpool_node
< VEC_length (varpool_node_ptr
,
1891 partition
->varpool_set
->
1894 struct ipa_ref_list
*refs
;
1896 struct ipa_ref
*ref
;
1897 bool cgraph_p
= false;
1899 if (last_visited_cgraph_node
<
1900 VEC_length (cgraph_node_ptr
, partition
->cgraph_set
->nodes
))
1902 struct cgraph_edge
*edge
;
1905 node
= VEC_index (cgraph_node_ptr
, partition
->cgraph_set
->nodes
,
1906 last_visited_cgraph_node
);
1907 refs
= &node
->ref_list
;
1909 last_visited_cgraph_node
++;
1911 gcc_assert (node
->analyzed
);
1913 /* Compute boundary cost of callgraph edges. */
1914 for (edge
= node
->callees
; edge
; edge
= edge
->next_callee
)
1915 if (edge
->callee
->analyzed
)
1917 int edge_cost
= edge
->frequency
;
1918 cgraph_node_set_iterator csi
;
1922 gcc_assert (edge_cost
> 0);
1923 csi
= cgraph_node_set_find (partition
->cgraph_set
, edge
->callee
);
1924 if (!csi_end_p (csi
)
1925 && csi
.index
< last_visited_cgraph_node
- 1)
1926 cost
-= edge_cost
, internal
+= edge_cost
;
1930 for (edge
= node
->callers
; edge
; edge
= edge
->next_caller
)
1932 int edge_cost
= edge
->frequency
;
1933 cgraph_node_set_iterator csi
;
1935 gcc_assert (edge
->caller
->analyzed
);
1938 gcc_assert (edge_cost
> 0);
1939 csi
= cgraph_node_set_find (partition
->cgraph_set
, edge
->caller
);
1940 if (!csi_end_p (csi
)
1941 && csi
.index
< last_visited_cgraph_node
)
1950 &VEC_index (varpool_node_ptr
, partition
->varpool_set
->nodes
,
1951 last_visited_varpool_node
)->ref_list
;
1952 last_visited_varpool_node
++;
1955 /* Compute boundary cost of IPA REF edges and at the same time look into
1956 variables referenced from current partition and try to add them. */
1957 for (j
= 0; ipa_ref_list_reference_iterate (refs
, j
, ref
); j
++)
1958 if (ref
->refered_type
== IPA_REF_VARPOOL
)
1960 varpool_node_set_iterator vsi
;
1962 vnode
= ipa_ref_varpool_node (ref
);
1963 if (!vnode
->finalized
)
1965 if (!vnode
->aux
&& flag_toplevel_reorder
1966 && partition_varpool_node_p (vnode
))
1967 add_varpool_node_to_partition (partition
, vnode
);
1968 vsi
= varpool_node_set_find (partition
->varpool_set
, vnode
);
1969 if (!vsi_end_p (vsi
)
1970 && vsi
.index
< last_visited_varpool_node
- !cgraph_p
)
1977 cgraph_node_set_iterator csi
;
1979 node
= ipa_ref_node (ref
);
1980 if (!node
->analyzed
)
1982 csi
= cgraph_node_set_find (partition
->cgraph_set
, node
);
1983 if (!csi_end_p (csi
)
1984 && csi
.index
< last_visited_cgraph_node
- cgraph_p
)
1989 for (j
= 0; ipa_ref_list_refering_iterate (refs
, j
, ref
); j
++)
1990 if (ref
->refering_type
== IPA_REF_VARPOOL
)
1992 varpool_node_set_iterator vsi
;
1994 vnode
= ipa_ref_refering_varpool_node (ref
);
1995 gcc_assert (vnode
->finalized
);
1996 if (!vnode
->aux
&& flag_toplevel_reorder
1997 && partition_varpool_node_p (vnode
))
1998 add_varpool_node_to_partition (partition
, vnode
);
1999 vsi
= varpool_node_set_find (partition
->varpool_set
, vnode
);
2000 if (!vsi_end_p (vsi
)
2001 && vsi
.index
< last_visited_varpool_node
)
2008 cgraph_node_set_iterator csi
;
2010 node
= ipa_ref_refering_node (ref
);
2011 gcc_assert (node
->analyzed
);
2012 csi
= cgraph_node_set_find (partition
->cgraph_set
, node
);
2013 if (!csi_end_p (csi
)
2014 && csi
.index
< last_visited_cgraph_node
)
2021 /* If the partition is large enough, start looking for smallest boundary cost. */
2022 if (partition
->insns
< partition_size
* 3 / 4
2023 || best_cost
== INT_MAX
2025 || (best_internal
* (HOST_WIDE_INT
) cost
2026 > (internal
* (HOST_WIDE_INT
)best_cost
)))
2027 && partition
->insns
< partition_size
* 5 / 4))
2030 best_internal
= internal
;
2032 best_n_nodes
= VEC_length (cgraph_node_ptr
,
2033 partition
->cgraph_set
->nodes
);
2034 best_n_varpool_nodes
= VEC_length (varpool_node_ptr
,
2035 partition
->varpool_set
->nodes
);
2036 best_total_size
= total_size
;
2038 if (cgraph_dump_file
)
2039 fprintf (cgraph_dump_file
, "Step %i: added %s/%i, size %i, cost %i/%i best %i/%i, step %i\n", i
,
2040 cgraph_node_name (order
[i
]), order
[i
]->uid
, partition
->insns
, cost
, internal
,
2041 best_cost
, best_internal
, best_i
);
2042 /* Partition is too large, unwind into step when best cost was reached and
2043 start new partition. */
2044 if (partition
->insns
> 2 * partition_size
)
2048 if (cgraph_dump_file
)
2049 fprintf (cgraph_dump_file
, "Unwinding %i insertions to step %i\n",
2050 i
- best_i
, best_i
);
2051 undo_partition (partition
, best_n_nodes
, best_n_varpool_nodes
);
2054 /* When we are finished, avoid creating empty partition. */
2055 while (i
< n_nodes
- 1 && order
[i
+ 1]->aux
)
2057 if (i
== n_nodes
- 1)
2059 partition
= new_partition ("");
2060 last_visited_cgraph_node
= 0;
2061 last_visited_varpool_node
= 0;
2062 total_size
= best_total_size
;
2065 if (cgraph_dump_file
)
2066 fprintf (cgraph_dump_file
, "New partition\n");
2068 best_n_varpool_nodes
= 0;
2069 best_cost
= INT_MAX
;
2071 /* Since the size of partitions is just approximate, update the size after
2072 we finished current one. */
2073 if (npartitions
< PARAM_VALUE (PARAM_LTO_PARTITIONS
))
2074 partition_size
= total_size
2075 / (PARAM_VALUE (PARAM_LTO_PARTITIONS
) - npartitions
);
2077 partition_size
= INT_MAX
;
2079 if (partition_size
< PARAM_VALUE (MIN_PARTITION_SIZE
))
2080 partition_size
= PARAM_VALUE (MIN_PARTITION_SIZE
);
2085 /* Varables that are not reachable from the code go into last partition. */
2086 if (flag_toplevel_reorder
)
2088 for (vnode
= varpool_nodes
; vnode
; vnode
= vnode
->next
)
2089 if (partition_varpool_node_p (vnode
) && !vnode
->aux
)
2090 add_varpool_node_to_partition (partition
, vnode
);
2094 while (varpool_pos
< n_varpool_nodes
)
2096 if (!varpool_order
[varpool_pos
]->aux
)
2097 add_varpool_node_to_partition (partition
, varpool_order
[varpool_pos
]);
2100 free (varpool_order
);
2105 /* Promote variable VNODE to be static. */
2108 promote_var (struct varpool_node
*vnode
)
2110 if (TREE_PUBLIC (vnode
->decl
) || DECL_EXTERNAL (vnode
->decl
))
2112 gcc_assert (flag_wpa
);
2113 TREE_PUBLIC (vnode
->decl
) = 1;
2114 DECL_VISIBILITY (vnode
->decl
) = VISIBILITY_HIDDEN
;
2115 DECL_VISIBILITY_SPECIFIED (vnode
->decl
) = true;
2116 if (cgraph_dump_file
)
2117 fprintf (cgraph_dump_file
,
2118 "Promoting var as hidden: %s\n", varpool_node_name (vnode
));
2122 /* Promote function NODE to be static. */
2125 promote_fn (struct cgraph_node
*node
)
2127 gcc_assert (flag_wpa
);
2128 if (TREE_PUBLIC (node
->decl
) || DECL_EXTERNAL (node
->decl
))
2130 TREE_PUBLIC (node
->decl
) = 1;
2131 DECL_VISIBILITY (node
->decl
) = VISIBILITY_HIDDEN
;
2132 DECL_VISIBILITY_SPECIFIED (node
->decl
) = true;
2133 if (cgraph_dump_file
)
2134 fprintf (cgraph_dump_file
,
2135 "Promoting function as hidden: %s/%i\n",
2136 cgraph_node_name (node
), node
->uid
);
2140 /* Find out all static decls that need to be promoted to global because
2141 of cross file sharing. This function must be run in the WPA mode after
2142 all inlinees are added. */
2145 lto_promote_cross_file_statics (void)
2147 struct varpool_node
*vnode
;
2149 cgraph_node_set set
;
2150 varpool_node_set vset
;
2151 cgraph_node_set_iterator csi
;
2152 varpool_node_set_iterator vsi
;
2153 VEC(varpool_node_ptr
, heap
) *promoted_initializers
= NULL
;
2154 struct pointer_set_t
*inserted
= pointer_set_create ();
2156 gcc_assert (flag_wpa
);
2158 n_sets
= VEC_length (ltrans_partition
, ltrans_partitions
);
2159 for (i
= 0; i
< n_sets
; i
++)
2161 ltrans_partition part
2162 = VEC_index (ltrans_partition
, ltrans_partitions
, i
);
2163 set
= part
->cgraph_set
;
2164 vset
= part
->varpool_set
;
2166 /* If node called or referred to from other partition, it needs to be
2168 for (csi
= csi_start (set
); !csi_end_p (csi
); csi_next (&csi
))
2170 struct cgraph_node
*node
= csi_node (csi
);
2171 if (node
->local
.externally_visible
)
2173 if (node
->global
.inlined_to
)
2175 if ((!DECL_EXTERNAL (node
->decl
) && !DECL_COMDAT (node
->decl
))
2176 && (referenced_from_other_partition_p (&node
->ref_list
, set
, vset
)
2177 || reachable_from_other_partition_p (node
, set
)))
2180 for (vsi
= vsi_start (vset
); !vsi_end_p (vsi
); vsi_next (&vsi
))
2182 vnode
= vsi_node (vsi
);
2183 /* Constant pool references use internal labels and thus can not
2184 be made global. It is sensible to keep those ltrans local to
2185 allow better optimization. */
2186 if (!DECL_IN_CONSTANT_POOL (vnode
->decl
) && !DECL_COMDAT (vnode
->decl
)
2187 && !vnode
->externally_visible
&& vnode
->analyzed
2188 && referenced_from_other_partition_p (&vnode
->ref_list
,
2190 promote_var (vnode
);
2193 /* We export the initializer of a read-only var into each partition
2194 referencing the var. Folding might take declarations from the
2195 initializer and use them, so everything referenced from the
2196 initializer can be accessed from this partition after folding.
2198 This means that we need to promote all variables and functions
2199 referenced from all initializers of read-only vars referenced
2200 from this partition that are not in this partition. This needs
2201 to be done recursively. */
2202 for (vnode
= varpool_nodes
; vnode
; vnode
= vnode
->next
)
2203 if (const_value_known_p (vnode
->decl
)
2204 && DECL_INITIAL (vnode
->decl
)
2205 && !varpool_node_in_set_p (vnode
, vset
)
2206 && referenced_from_this_partition_p (&vnode
->ref_list
, set
, vset
)
2207 && !pointer_set_insert (inserted
, vnode
))
2208 VEC_safe_push (varpool_node_ptr
, heap
, promoted_initializers
, vnode
);
2210 while (!VEC_empty (varpool_node_ptr
, promoted_initializers
))
2213 struct ipa_ref
*ref
;
2215 vnode
= VEC_pop (varpool_node_ptr
, promoted_initializers
);
2217 ipa_ref_list_reference_iterate (&vnode
->ref_list
, i
, ref
);
2220 if (ref
->refered_type
== IPA_REF_CGRAPH
)
2222 struct cgraph_node
*n
= ipa_ref_node (ref
);
2223 gcc_assert (!n
->global
.inlined_to
);
2224 if (!n
->local
.externally_visible
2225 && !cgraph_node_in_set_p (n
, set
))
2230 struct varpool_node
*v
= ipa_ref_varpool_node (ref
);
2231 if (varpool_node_in_set_p (v
, vset
))
2234 /* Constant pool references use internal labels and thus
2235 cannot be made global. It is sensible to keep those
2236 ltrans local to allow better optimization. */
2237 if (DECL_IN_CONSTANT_POOL (v
->decl
))
2239 if (!pointer_set_insert (inserted
, vnode
))
2240 VEC_safe_push (varpool_node_ptr
, heap
,
2241 promoted_initializers
, v
);
2243 else if (!v
->externally_visible
&& v
->analyzed
)
2246 && DECL_INITIAL (v
->decl
)
2247 && const_value_known_p (v
->decl
)
2248 && !pointer_set_insert (inserted
, vnode
))
2249 VEC_safe_push (varpool_node_ptr
, heap
,
2250 promoted_initializers
, v
);
2256 pointer_set_destroy (inserted
);
2259 static lto_file
*current_lto_file
;
2261 /* Helper for qsort; compare partitions and return one with smaller size.
2262 We sort from greatest to smallest so parallel build doesn't stale on the
2263 longest compilation being executed too late. */
2266 cmp_partitions_size (const void *a
, const void *b
)
2268 const struct ltrans_partition_def
*pa
2269 = *(struct ltrans_partition_def
*const *)a
;
2270 const struct ltrans_partition_def
*pb
2271 = *(struct ltrans_partition_def
*const *)b
;
2272 return pb
->insns
- pa
->insns
;
2275 /* Helper for qsort; compare partitions and return one with smaller order. */
2278 cmp_partitions_order (const void *a
, const void *b
)
2280 const struct ltrans_partition_def
*pa
2281 = *(struct ltrans_partition_def
*const *)a
;
2282 const struct ltrans_partition_def
*pb
2283 = *(struct ltrans_partition_def
*const *)b
;
2284 int ordera
= -1, orderb
= -1;
2286 if (VEC_length (cgraph_node_ptr
, pa
->cgraph_set
->nodes
))
2287 ordera
= VEC_index (cgraph_node_ptr
, pa
->cgraph_set
->nodes
, 0)->order
;
2288 else if (VEC_length (varpool_node_ptr
, pa
->varpool_set
->nodes
))
2289 ordera
= VEC_index (varpool_node_ptr
, pa
->varpool_set
->nodes
, 0)->order
;
2290 if (VEC_length (cgraph_node_ptr
, pb
->cgraph_set
->nodes
))
2291 orderb
= VEC_index (cgraph_node_ptr
, pb
->cgraph_set
->nodes
, 0)->order
;
2292 else if (VEC_length (varpool_node_ptr
, pb
->varpool_set
->nodes
))
2293 orderb
= VEC_index (varpool_node_ptr
, pb
->varpool_set
->nodes
, 0)->order
;
2294 return orderb
- ordera
;
2297 /* Write all output files in WPA mode and the file with the list of
2301 lto_wpa_write_files (void)
2305 cgraph_node_set set
;
2306 varpool_node_set vset
;
2307 ltrans_partition part
;
2308 FILE *ltrans_output_list_stream
;
2309 char *temp_filename
;
2312 /* Open the LTRANS output list. */
2313 if (!ltrans_output_list
)
2314 fatal_error ("no LTRANS output list filename provided");
2315 ltrans_output_list_stream
= fopen (ltrans_output_list
, "w");
2316 if (ltrans_output_list_stream
== NULL
)
2317 fatal_error ("opening LTRANS output list %s: %m", ltrans_output_list
);
2319 timevar_push (TV_WHOPR_WPA
);
2321 FOR_EACH_VEC_ELT (ltrans_partition
, ltrans_partitions
, i
, part
)
2322 lto_stats
.num_output_cgraph_nodes
+= VEC_length (cgraph_node_ptr
,
2323 part
->cgraph_set
->nodes
);
2325 /* Find out statics that need to be promoted
2326 to globals with hidden visibility because they are accessed from multiple
2328 lto_promote_cross_file_statics ();
2330 timevar_pop (TV_WHOPR_WPA
);
2332 timevar_push (TV_WHOPR_WPA_IO
);
2334 /* Generate a prefix for the LTRANS unit files. */
2335 blen
= strlen (ltrans_output_list
);
2336 temp_filename
= (char *) xmalloc (blen
+ sizeof ("2147483648.o"));
2337 strcpy (temp_filename
, ltrans_output_list
);
2338 if (blen
> sizeof (".out")
2339 && strcmp (temp_filename
+ blen
- sizeof (".out") + 1,
2341 temp_filename
[blen
- sizeof (".out") + 1] = '\0';
2342 blen
= strlen (temp_filename
);
2344 n_sets
= VEC_length (ltrans_partition
, ltrans_partitions
);
2346 /* Sort partitions by size so small ones are compiled last.
2347 FIXME: Even when not reordering we may want to output one list for parallel make
2348 and other for final link command. */
2349 VEC_qsort (ltrans_partition
, ltrans_partitions
,
2350 flag_toplevel_reorder
? cmp_partitions_size
: cmp_partitions_order
);
2351 for (i
= 0; i
< n_sets
; i
++)
2354 ltrans_partition part
= VEC_index (ltrans_partition
, ltrans_partitions
, i
);
2356 set
= part
->cgraph_set
;
2357 vset
= part
->varpool_set
;
2359 /* Write all the nodes in SET. */
2360 sprintf (temp_filename
+ blen
, "%u.o", i
);
2361 file
= lto_obj_file_open (temp_filename
, true);
2363 fatal_error ("lto_obj_file_open() failed");
2366 fprintf (stderr
, " %s (%s %i insns)", temp_filename
, part
->name
, part
->insns
);
2367 if (cgraph_dump_file
)
2369 fprintf (cgraph_dump_file
, "Writing partition %s to file %s, %i insns\n",
2370 part
->name
, temp_filename
, part
->insns
);
2371 fprintf (cgraph_dump_file
, "cgraph nodes:");
2372 dump_cgraph_node_set (cgraph_dump_file
, set
);
2373 fprintf (cgraph_dump_file
, "varpool nodes:");
2374 dump_varpool_node_set (cgraph_dump_file
, vset
);
2376 gcc_checking_assert (cgraph_node_set_nonempty_p (set
)
2377 || varpool_node_set_nonempty_p (vset
) || !i
);
2379 lto_set_current_out_file (file
);
2381 ipa_write_optimization_summaries (set
, vset
);
2383 lto_set_current_out_file (NULL
);
2384 lto_obj_file_close (file
);
2386 len
= strlen (temp_filename
);
2387 if (fwrite (temp_filename
, 1, len
, ltrans_output_list_stream
) < len
2388 || fwrite ("\n", 1, 1, ltrans_output_list_stream
) < 1)
2389 fatal_error ("writing to LTRANS output list %s: %m",
2390 ltrans_output_list
);
2393 lto_stats
.num_output_files
+= n_sets
;
2395 /* Close the LTRANS output list. */
2396 if (fclose (ltrans_output_list_stream
))
2397 fatal_error ("closing LTRANS output list %s: %m", ltrans_output_list
);
2399 free_ltrans_partitions();
2401 timevar_pop (TV_WHOPR_WPA_IO
);
2405 /* If TT is a variable or function decl replace it with its
2406 prevailing variant. */
2407 #define LTO_SET_PREVAIL(tt) \
2409 if ((tt) && VAR_OR_FUNCTION_DECL_P (tt)) \
2410 tt = lto_symtab_prevailing_decl (tt); \
2413 /* Ensure that TT isn't a replacable var of function decl. */
2414 #define LTO_NO_PREVAIL(tt) \
2415 gcc_assert (!(tt) || !VAR_OR_FUNCTION_DECL_P (tt))
2417 /* Given a tree T replace all fields referring to variables or functions
2418 with their prevailing variant. */
2420 lto_fixup_prevailing_decls (tree t
)
2422 enum tree_code code
= TREE_CODE (t
);
2423 LTO_NO_PREVAIL (TREE_TYPE (t
));
2424 if (CODE_CONTAINS_STRUCT (code
, TS_COMMON
))
2425 LTO_NO_PREVAIL (TREE_CHAIN (t
));
2428 LTO_NO_PREVAIL (DECL_NAME (t
));
2429 LTO_SET_PREVAIL (DECL_CONTEXT (t
));
2430 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_COMMON
))
2432 LTO_SET_PREVAIL (DECL_SIZE (t
));
2433 LTO_SET_PREVAIL (DECL_SIZE_UNIT (t
));
2434 LTO_SET_PREVAIL (DECL_INITIAL (t
));
2435 LTO_NO_PREVAIL (DECL_ATTRIBUTES (t
));
2436 LTO_SET_PREVAIL (DECL_ABSTRACT_ORIGIN (t
));
2438 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_WITH_VIS
))
2440 LTO_NO_PREVAIL (t
->decl_with_vis
.assembler_name
);
2441 LTO_NO_PREVAIL (DECL_SECTION_NAME (t
));
2443 if (CODE_CONTAINS_STRUCT (code
, TS_DECL_NON_COMMON
))
2445 LTO_NO_PREVAIL (DECL_ARGUMENT_FLD (t
));
2446 LTO_NO_PREVAIL (DECL_RESULT_FLD (t
));
2447 LTO_NO_PREVAIL (DECL_VINDEX (t
));
2449 if (CODE_CONTAINS_STRUCT (code
, TS_FUNCTION_DECL
))
2450 LTO_SET_PREVAIL (DECL_FUNCTION_PERSONALITY (t
));
2451 if (CODE_CONTAINS_STRUCT (code
, TS_FIELD_DECL
))
2453 LTO_NO_PREVAIL (DECL_FIELD_OFFSET (t
));
2454 LTO_NO_PREVAIL (DECL_BIT_FIELD_TYPE (t
));
2455 LTO_NO_PREVAIL (DECL_QUALIFIER (t
));
2456 LTO_NO_PREVAIL (DECL_FIELD_BIT_OFFSET (t
));
2457 LTO_NO_PREVAIL (DECL_FCONTEXT (t
));
2460 else if (TYPE_P (t
))
2462 LTO_NO_PREVAIL (TYPE_CACHED_VALUES (t
));
2463 LTO_SET_PREVAIL (TYPE_SIZE (t
));
2464 LTO_SET_PREVAIL (TYPE_SIZE_UNIT (t
));
2465 LTO_NO_PREVAIL (TYPE_ATTRIBUTES (t
));
2466 LTO_NO_PREVAIL (TYPE_NAME (t
));
2468 LTO_SET_PREVAIL (TYPE_MINVAL (t
));
2469 LTO_SET_PREVAIL (TYPE_MAXVAL (t
));
2470 LTO_SET_PREVAIL (t
->type_non_common
.binfo
);
2472 LTO_SET_PREVAIL (TYPE_CONTEXT (t
));
2474 LTO_NO_PREVAIL (TYPE_CANONICAL (t
));
2475 LTO_NO_PREVAIL (TYPE_MAIN_VARIANT (t
));
2476 LTO_NO_PREVAIL (TYPE_NEXT_VARIANT (t
));
2478 else if (EXPR_P (t
))
2481 LTO_NO_PREVAIL (t
->exp
.block
);
2482 for (i
= TREE_OPERAND_LENGTH (t
) - 1; i
>= 0; --i
)
2483 LTO_SET_PREVAIL (TREE_OPERAND (t
, i
));
2490 LTO_SET_PREVAIL (TREE_VALUE (t
));
2491 LTO_SET_PREVAIL (TREE_PURPOSE (t
));
2498 #undef LTO_SET_PREVAIL
2499 #undef LTO_NO_PREVAIL
2501 /* Helper function of lto_fixup_decls. Walks the var and fn streams in STATE,
2502 replaces var and function decls with the corresponding prevailing def. */
2505 lto_fixup_state (struct lto_in_decl_state
*state
)
2508 struct lto_tree_ref_table
*table
;
2510 /* Although we only want to replace FUNCTION_DECLs and VAR_DECLs,
2511 we still need to walk from all DECLs to find the reachable
2512 FUNCTION_DECLs and VAR_DECLs. */
2513 for (si
= 0; si
< LTO_N_DECL_STREAMS
; si
++)
2515 table
= &state
->streams
[si
];
2516 for (i
= 0; i
< table
->size
; i
++)
2518 tree
*tp
= table
->trees
+ i
;
2519 if (VAR_OR_FUNCTION_DECL_P (*tp
))
2520 *tp
= lto_symtab_prevailing_decl (*tp
);
2525 /* A callback of htab_traverse. Just extracts a state from SLOT
2526 and calls lto_fixup_state. */
2529 lto_fixup_state_aux (void **slot
, void *aux ATTRIBUTE_UNUSED
)
2531 struct lto_in_decl_state
*state
= (struct lto_in_decl_state
*) *slot
;
2532 lto_fixup_state (state
);
2536 /* Fix the decls from all FILES. Replaces each decl with the corresponding
2540 lto_fixup_decls (struct lto_file_decl_data
**files
)
2546 FOR_EACH_HTAB_ELEMENT (tree_with_vars
, t
, tree
, hi
)
2547 lto_fixup_prevailing_decls (t
);
2549 for (i
= 0; files
[i
]; i
++)
2551 struct lto_file_decl_data
*file
= files
[i
];
2552 struct lto_in_decl_state
*state
= file
->global_decl_state
;
2553 lto_fixup_state (state
);
2555 htab_traverse (file
->function_decl_states
, lto_fixup_state_aux
, NULL
);
2559 static GTY((length ("lto_stats.num_input_files + 1"))) struct lto_file_decl_data
**all_file_decl_data
;
2561 /* Turn file datas for sub files into a single array, so that they look
2562 like separate files for further passes. */
2565 lto_flatten_files (struct lto_file_decl_data
**orig
, int count
, int last_file_ix
)
2567 struct lto_file_decl_data
*n
, *next
;
2570 lto_stats
.num_input_files
= count
;
2572 = ggc_alloc_cleared_vec_lto_file_decl_data_ptr (count
+ 1);
2573 /* Set the hooks so that all of the ipa passes can read in their data. */
2574 lto_set_in_hooks (all_file_decl_data
, get_section_data
, free_section_data
);
2575 for (i
= 0, k
= 0; i
< last_file_ix
; i
++)
2577 for (n
= orig
[i
]; n
!= NULL
; n
= next
)
2579 all_file_decl_data
[k
++] = n
;
2584 all_file_decl_data
[k
] = NULL
;
2585 gcc_assert (k
== count
);
2588 /* Input file data before flattening (i.e. splitting them to subfiles to support
2589 incremental linking. */
2590 static int real_file_count
;
2591 static GTY((length ("real_file_count + 1"))) struct lto_file_decl_data
**real_file_decl_data
;
2593 /* Read all the symbols from the input files FNAMES. NFILES is the
2594 number of files requested in the command line. Instantiate a
2595 global call graph by aggregating all the sub-graphs found in each
2599 read_cgraph_and_symbols (unsigned nfiles
, const char **fnames
)
2601 unsigned int i
, last_file_ix
;
2603 struct cgraph_node
*node
;
2605 struct lto_file_decl_data
**decl_data
;
2609 timevar_push (TV_IPA_LTO_DECL_IN
);
2612 = decl_data
= ggc_alloc_cleared_vec_lto_file_decl_data_ptr (nfiles
+ 1);
2613 real_file_count
= nfiles
;
2615 /* Read the resolution file. */
2617 if (resolution_file_name
)
2620 unsigned num_objects
;
2622 resolution
= fopen (resolution_file_name
, "r");
2623 if (resolution
== NULL
)
2624 fatal_error ("could not open symbol resolution file: %m");
2626 t
= fscanf (resolution
, "%u", &num_objects
);
2627 gcc_assert (t
== 1);
2629 /* True, since the plugin splits the archives. */
2630 gcc_assert (num_objects
== nfiles
);
2633 tree_with_vars
= htab_create_ggc (101, htab_hash_pointer
, htab_eq_pointer
,
2637 fprintf (stderr
, "Reading object files:");
2639 /* Read all of the object files specified on the command line. */
2640 for (i
= 0, last_file_ix
= 0; i
< nfiles
; ++i
)
2642 struct lto_file_decl_data
*file_data
= NULL
;
2645 fprintf (stderr
, " %s", fnames
[i
]);
2649 current_lto_file
= lto_obj_file_open (fnames
[i
], false);
2650 if (!current_lto_file
)
2653 file_data
= lto_file_read (current_lto_file
, resolution
, &count
);
2656 lto_obj_file_close (current_lto_file
);
2657 current_lto_file
= NULL
;
2661 decl_data
[last_file_ix
++] = file_data
;
2663 lto_obj_file_close (current_lto_file
);
2664 current_lto_file
= NULL
;
2668 lto_flatten_files (decl_data
, count
, last_file_ix
);
2669 lto_stats
.num_input_files
= count
;
2670 ggc_free(decl_data
);
2671 real_file_decl_data
= NULL
;
2673 if (resolution_file_name
)
2674 fclose (resolution
);
2676 /* Set the hooks so that all of the ipa passes can read in their data. */
2677 lto_set_in_hooks (all_file_decl_data
, get_section_data
, free_section_data
);
2679 timevar_pop (TV_IPA_LTO_DECL_IN
);
2682 fprintf (stderr
, "\nReading the callgraph\n");
2684 timevar_push (TV_IPA_LTO_CGRAPH_IO
);
2685 /* Read the callgraph. */
2687 timevar_pop (TV_IPA_LTO_CGRAPH_IO
);
2690 fprintf (stderr
, "Merging declarations\n");
2692 timevar_push (TV_IPA_LTO_DECL_MERGE
);
2693 /* Merge global decls. */
2694 lto_symtab_merge_decls ();
2696 /* If there were errors during symbol merging bail out, we have no
2697 good way to recover here. */
2699 fatal_error ("errors during merging of translation units");
2701 /* Fixup all decls and types and free the type hash tables. */
2702 lto_fixup_decls (all_file_decl_data
);
2703 htab_delete (tree_with_vars
);
2704 tree_with_vars
= NULL
;
2705 free_gimple_type_tables ();
2708 timevar_pop (TV_IPA_LTO_DECL_MERGE
);
2709 /* Each pass will set the appropriate timer. */
2712 fprintf (stderr
, "Reading summaries\n");
2714 /* Read the IPA summary data. */
2716 ipa_read_optimization_summaries ();
2718 ipa_read_summaries ();
2720 /* Finally merge the cgraph according to the decl merging decisions. */
2721 timevar_push (TV_IPA_LTO_CGRAPH_MERGE
);
2722 if (cgraph_dump_file
)
2724 fprintf (cgraph_dump_file
, "Before merging:\n");
2725 dump_cgraph (cgraph_dump_file
);
2726 dump_varpool (cgraph_dump_file
);
2728 lto_symtab_merge_cgraph_nodes ();
2732 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2734 /* FIXME: ipa_transforms_to_apply holds list of passes that have optimization
2735 summaries computed and needs to apply changes. At the moment WHOPR only
2736 supports inlining, so we can push it here by hand. In future we need to stream
2737 this field into ltrans compilation. */
2739 VEC_safe_push (ipa_opt_pass
, heap
,
2740 node
->ipa_transforms_to_apply
,
2741 (ipa_opt_pass
)&pass_ipa_inline
);
2745 timevar_pop (TV_IPA_LTO_CGRAPH_MERGE
);
2747 timevar_push (TV_IPA_LTO_DECL_INIT_IO
);
2749 /* FIXME lto. This loop needs to be changed to use the pass manager to
2750 call the ipa passes directly. */
2752 for (i
= 0; i
< last_file_ix
; i
++)
2754 struct lto_file_decl_data
*file_data
= all_file_decl_data
[i
];
2755 lto_materialize_constructors_and_inits (file_data
);
2758 /* Indicate that the cgraph is built and ready. */
2759 cgraph_function_flags_ready
= true;
2761 timevar_pop (TV_IPA_LTO_DECL_INIT_IO
);
2762 ggc_free (all_file_decl_data
);
2763 all_file_decl_data
= NULL
;
2767 /* Materialize all the bodies for all the nodes in the callgraph. */
2770 materialize_cgraph (void)
2773 struct cgraph_node
*node
;
2775 timevar_id_t lto_timer
;
2779 flag_wpa
? "Materializing decls:" : "Reading function bodies:");
2782 /* Now that we have input the cgraph, we need to clear all of the aux
2783 nodes and read the functions if we are not running in WPA mode. */
2784 timevar_push (TV_IPA_LTO_GIMPLE_IN
);
2786 for (node
= cgraph_nodes
; node
; node
= node
->next
)
2788 if (node
->local
.lto_file_data
)
2790 lto_materialize_function (node
);
2791 lto_stats
.num_input_cgraph_nodes
++;
2795 timevar_pop (TV_IPA_LTO_GIMPLE_IN
);
2797 /* Start the appropriate timer depending on the mode that we are
2799 lto_timer
= (flag_wpa
) ? TV_WHOPR_WPA
2800 : (flag_ltrans
) ? TV_WHOPR_LTRANS
2802 timevar_push (lto_timer
);
2804 current_function_decl
= NULL
;
2807 /* Inform the middle end about the global variables we have seen. */
2808 FOR_EACH_VEC_ELT (tree
, lto_global_var_decls
, i
, decl
)
2809 rest_of_decl_compilation (decl
, 1, 0);
2812 fprintf (stderr
, "\n");
2814 timevar_pop (lto_timer
);
2818 /* Perform whole program analysis (WPA) on the callgraph and write out the
2819 optimization plan. */
2822 do_whole_program_analysis (void)
2824 /* Note that since we are in WPA mode, materialize_cgraph will not
2825 actually read in all the function bodies. It only materializes
2826 the decls and cgraph nodes so that analysis can be performed. */
2827 materialize_cgraph ();
2829 /* Reading in the cgraph uses different timers, start timing WPA now. */
2830 timevar_push (TV_WHOPR_WPA
);
2832 if (pre_ipa_mem_report
)
2834 fprintf (stderr
, "Memory consumption before IPA\n");
2835 dump_memory_report (false);
2838 cgraph_function_flags_ready
= true;
2840 if (cgraph_dump_file
)
2842 dump_cgraph (cgraph_dump_file
);
2843 dump_varpool (cgraph_dump_file
);
2845 bitmap_obstack_initialize (NULL
);
2846 cgraph_state
= CGRAPH_STATE_IPA_SSA
;
2848 execute_ipa_pass_list (all_regular_ipa_passes
);
2850 if (cgraph_dump_file
)
2852 fprintf (cgraph_dump_file
, "Optimized ");
2853 dump_cgraph (cgraph_dump_file
);
2854 dump_varpool (cgraph_dump_file
);
2857 bitmap_obstack_release (NULL
);
2859 /* We are about to launch the final LTRANS phase, stop the WPA timer. */
2860 timevar_pop (TV_WHOPR_WPA
);
2862 if (flag_lto_partition_1to1
)
2865 lto_balanced_map ();
2869 fprintf (stderr
, "\nStreaming out");
2872 lto_wpa_write_files ();
2875 fprintf (stderr
, "\n");
2877 if (post_ipa_mem_report
)
2879 fprintf (stderr
, "Memory consumption after IPA\n");
2880 dump_memory_report (false);
2883 /* Show the LTO report before launching LTRANS. */
2884 if (flag_lto_report
)
2885 print_lto_report ();
2889 static GTY(()) tree lto_eh_personality_decl
;
2891 /* Return the LTO personality function decl. */
2894 lto_eh_personality (void)
2896 if (!lto_eh_personality_decl
)
2898 /* Use the first personality DECL for our personality if we don't
2899 support multiple ones. This ensures that we don't artificially
2900 create the need for them in a single-language program. */
2901 if (first_personality_decl
&& !dwarf2out_do_cfi_asm ())
2902 lto_eh_personality_decl
= first_personality_decl
;
2904 lto_eh_personality_decl
= lhd_gcc_personality ();
2907 return lto_eh_personality_decl
;
2910 /* Set the process name based on the LTO mode. */
2913 lto_process_name (void)
2916 setproctitle ("lto1-lto");
2918 setproctitle ("lto1-wpa");
2920 setproctitle ("lto1-ltrans");
2924 /* Initialize the LTO front end. */
2929 lto_process_name ();
2930 lto_streamer_hooks_init ();
2932 lto_set_in_hooks (NULL
, get_section_data
, free_section_data
);
2933 memset (<o_stats
, 0, sizeof (lto_stats
));
2934 bitmap_obstack_initialize (NULL
);
2935 gimple_register_cfg_hooks ();
2939 /* Main entry point for the GIMPLE front end. This front end has
2940 three main personalities:
2942 - LTO (-flto). All the object files on the command line are
2943 loaded in memory and processed as a single translation unit.
2944 This is the traditional link-time optimization behavior.
2946 - WPA (-fwpa). Only the callgraph and summary information for
2947 files in the command file are loaded. A single callgraph
2948 (without function bodies) is instantiated for the whole set of
2949 files. IPA passes are only allowed to analyze the call graph
2950 and make transformation decisions. The callgraph is
2951 partitioned, each partition is written to a new object file
2952 together with the transformation decisions.
2954 - LTRANS (-fltrans). Similar to -flto but it prevents the IPA
2955 summary files from running again. Since WPA computed summary
2956 information and decided what transformations to apply, LTRANS
2957 simply applies them. */
2962 /* Initialize the LTO front end. */
2965 /* Read all the symbols and call graph from all the files in the
2967 read_cgraph_and_symbols (num_in_fnames
, in_fnames
);
2971 /* If WPA is enabled analyze the whole call graph and create an
2972 optimization plan. Otherwise, read in all the function
2973 bodies and continue with optimization. */
2975 do_whole_program_analysis ();
2978 materialize_cgraph ();
2980 /* Let the middle end know that we have read and merged all of
2984 /* FIXME lto, if the processes spawned by WPA fail, we miss
2985 the chance to print WPA's report, so WPA will call
2986 print_lto_report before launching LTRANS. If LTRANS was
2987 launched directly by the driver we would not need to do
2989 if (flag_lto_report
)
2990 print_lto_report ();
2995 #include "gt-lto-lto.h"