1 /* Miscellaneous utilities for GIMPLE streaming. Things that are used
2 in both input and output are here.
4 Copyright 2009, 2010 Free Software Foundation, Inc.
5 Contributed by Doug Kwan <dougkwan@google.com>
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 3, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
31 #include "tree-flow.h"
32 #include "diagnostic-core.h"
35 #include "lto-streamer.h"
37 /* Statistics gathered during LTO, WPA and LTRANS. */
38 struct lto_stats_d lto_stats
;
40 /* LTO uses bitmaps with different life-times. So use a seperate
41 obstack for all LTO bitmaps. */
42 static bitmap_obstack lto_obstack
;
43 static bool lto_obstack_initialized
;
46 /* Return a string representing LTO tag TAG. */
49 lto_tag_name (enum LTO_tags tag
)
51 if (lto_tag_is_tree_code_p (tag
))
53 /* For tags representing tree nodes, return the name of the
54 associated tree code. */
55 return tree_code_name
[lto_tag_to_tree_code (tag
)];
58 if (lto_tag_is_gimple_code_p (tag
))
60 /* For tags representing gimple statements, return the name of
61 the associated gimple code. */
62 return gimple_code_name
[lto_tag_to_gimple_code (tag
)];
74 return "LTO_eh_region";
76 return "LTO_function";
78 return "LTO_eh_table";
80 return "LTO_ert_cleanup";
83 case LTO_ert_allowed_exceptions
:
84 return "LTO_ert_allowed_exceptions";
85 case LTO_ert_must_not_throw
:
86 return "LTO_ert_must_not_throw";
87 case LTO_tree_pickle_reference
:
88 return "LTO_tree_pickle_reference";
89 case LTO_field_decl_ref
:
90 return "LTO_field_decl_ref";
91 case LTO_function_decl_ref
:
92 return "LTO_function_decl_ref";
93 case LTO_label_decl_ref
:
94 return "LTO_label_decl_ref";
95 case LTO_namespace_decl_ref
:
96 return "LTO_namespace_decl_ref";
97 case LTO_result_decl_ref
:
98 return "LTO_result_decl_ref";
99 case LTO_ssa_name_ref
:
100 return "LTO_ssa_name_ref";
101 case LTO_type_decl_ref
:
102 return "LTO_type_decl_ref";
104 return "LTO_type_ref";
105 case LTO_global_decl_ref
:
106 return "LTO_global_decl_ref";
108 return "LTO_UNKNOWN";
113 /* Allocate a bitmap from heap. Initializes the LTO obstack if necessary. */
116 lto_bitmap_alloc (void)
118 if (!lto_obstack_initialized
)
120 bitmap_obstack_initialize (<o_obstack
);
121 lto_obstack_initialized
= true;
123 return BITMAP_ALLOC (<o_obstack
);
129 lto_bitmap_free (bitmap b
)
135 /* Get a section name for a particular type or name. The NAME field
136 is only used if SECTION_TYPE is LTO_section_function_body. For all
137 others it is ignored. The callee of this function is responsible
138 to free the returned name. */
141 lto_get_section_name (int section_type
, const char *name
, struct lto_file_decl_data
*f
)
147 if (section_type
== LTO_section_function_body
)
149 gcc_assert (name
!= NULL
);
155 else if (section_type
< LTO_N_SECTION_TYPES
)
157 add
= lto_section_name
[section_type
];
161 internal_error ("bytecode stream: unexpected LTO section %s", name
);
163 /* Make the section name unique so that ld -r combining sections
164 doesn't confuse the reader with merged sections.
166 For options don't add a ID, the option reader cannot deal with them
167 and merging should be ok here.
169 XXX: use crc64 to minimize collisions? */
170 if (section_type
== LTO_section_opts
)
173 sprintf (post
, ".%x", f
? f
->id
: crc32_string(0, get_random_seed (false)));
174 return concat (LTO_SECTION_NAME_PREFIX
, sep
, add
, post
, NULL
);
178 /* Show various memory usage statistics related to LTO. */
181 print_lto_report (void)
183 const char *s
= (flag_lto
) ? "LTO" : (flag_wpa
) ? "WPA" : "LTRANS";
186 fprintf (stderr
, "%s statistics\n", s
);
187 fprintf (stderr
, "[%s] # of input files: "
188 HOST_WIDE_INT_PRINT_UNSIGNED
"\n", s
, lto_stats
.num_input_files
);
190 fprintf (stderr
, "[%s] # of input cgraph nodes: "
191 HOST_WIDE_INT_PRINT_UNSIGNED
"\n", s
,
192 lto_stats
.num_input_cgraph_nodes
);
194 fprintf (stderr
, "[%s] # of function bodies: "
195 HOST_WIDE_INT_PRINT_UNSIGNED
"\n", s
,
196 lto_stats
.num_function_bodies
);
198 fprintf (stderr
, "[%s] ", s
);
199 print_gimple_types_stats ();
201 for (i
= 0; i
< NUM_TREE_CODES
; i
++)
202 if (lto_stats
.num_trees
[i
])
203 fprintf (stderr
, "[%s] # of '%s' objects read: "
204 HOST_WIDE_INT_PRINT_UNSIGNED
"\n", s
,
205 tree_code_name
[i
], lto_stats
.num_trees
[i
]);
209 fprintf (stderr
, "[%s] Compression: "
210 HOST_WIDE_INT_PRINT_UNSIGNED
" output bytes, "
211 HOST_WIDE_INT_PRINT_UNSIGNED
" compressed bytes", s
,
212 lto_stats
.num_output_il_bytes
,
213 lto_stats
.num_compressed_il_bytes
);
214 if (lto_stats
.num_output_il_bytes
> 0)
216 const float dividend
= (float) lto_stats
.num_compressed_il_bytes
;
217 const float divisor
= (float) lto_stats
.num_output_il_bytes
;
218 fprintf (stderr
, " (ratio: %f)", dividend
/ divisor
);
220 fprintf (stderr
, "\n");
225 fprintf (stderr
, "[%s] # of output files: "
226 HOST_WIDE_INT_PRINT_UNSIGNED
"\n", s
,
227 lto_stats
.num_output_files
);
229 fprintf (stderr
, "[%s] # of output cgraph nodes: "
230 HOST_WIDE_INT_PRINT_UNSIGNED
"\n", s
,
231 lto_stats
.num_output_cgraph_nodes
);
233 fprintf (stderr
, "[%s] # callgraph partitions: "
234 HOST_WIDE_INT_PRINT_UNSIGNED
"\n", s
,
235 lto_stats
.num_cgraph_partitions
);
237 fprintf (stderr
, "[%s] Compression: "
238 HOST_WIDE_INT_PRINT_UNSIGNED
" input bytes, "
239 HOST_WIDE_INT_PRINT_UNSIGNED
" uncompressed bytes", s
,
240 lto_stats
.num_input_il_bytes
,
241 lto_stats
.num_uncompressed_il_bytes
);
242 if (lto_stats
.num_input_il_bytes
> 0)
244 const float dividend
= (float) lto_stats
.num_uncompressed_il_bytes
;
245 const float divisor
= (float) lto_stats
.num_input_il_bytes
;
246 fprintf (stderr
, " (ratio: %f)", dividend
/ divisor
);
248 fprintf (stderr
, "\n");
251 for (i
= 0; i
< LTO_N_SECTION_TYPES
; i
++)
252 fprintf (stderr
, "[%s] Size of mmap'd section %s: "
253 HOST_WIDE_INT_PRINT_UNSIGNED
" bytes\n", s
,
254 lto_section_name
[i
], lto_stats
.section_size
[i
]);
258 /* Check that all the TS_* structures handled by the lto_output_* and
259 lto_input_* routines are exactly ALL the structures defined in
263 check_handled_ts_structures (void)
265 bool handled_p
[LAST_TS_ENUM
];
268 memset (&handled_p
, 0, sizeof (handled_p
));
270 /* These are the TS_* structures that are either handled or
271 explicitly ignored by the streamer routines. */
272 handled_p
[TS_BASE
] = true;
273 handled_p
[TS_TYPED
] = true;
274 handled_p
[TS_COMMON
] = true;
275 handled_p
[TS_INT_CST
] = true;
276 handled_p
[TS_REAL_CST
] = true;
277 handled_p
[TS_FIXED_CST
] = true;
278 handled_p
[TS_VECTOR
] = true;
279 handled_p
[TS_STRING
] = true;
280 handled_p
[TS_COMPLEX
] = true;
281 handled_p
[TS_IDENTIFIER
] = true;
282 handled_p
[TS_DECL_MINIMAL
] = true;
283 handled_p
[TS_DECL_COMMON
] = true;
284 handled_p
[TS_DECL_WRTL
] = true;
285 handled_p
[TS_DECL_NON_COMMON
] = true;
286 handled_p
[TS_DECL_WITH_VIS
] = true;
287 handled_p
[TS_FIELD_DECL
] = true;
288 handled_p
[TS_VAR_DECL
] = true;
289 handled_p
[TS_PARM_DECL
] = true;
290 handled_p
[TS_LABEL_DECL
] = true;
291 handled_p
[TS_RESULT_DECL
] = true;
292 handled_p
[TS_CONST_DECL
] = true;
293 handled_p
[TS_TYPE_DECL
] = true;
294 handled_p
[TS_FUNCTION_DECL
] = true;
295 handled_p
[TS_TYPE
] = true;
296 handled_p
[TS_LIST
] = true;
297 handled_p
[TS_VEC
] = true;
298 handled_p
[TS_EXP
] = true;
299 handled_p
[TS_SSA_NAME
] = true;
300 handled_p
[TS_BLOCK
] = true;
301 handled_p
[TS_BINFO
] = true;
302 handled_p
[TS_STATEMENT_LIST
] = true;
303 handled_p
[TS_CONSTRUCTOR
] = true;
304 handled_p
[TS_OMP_CLAUSE
] = true;
305 handled_p
[TS_OPTIMIZATION
] = true;
306 handled_p
[TS_TARGET_OPTION
] = true;
307 handled_p
[TS_TRANSLATION_UNIT_DECL
] = true;
309 /* Anything not marked above will trigger the following assertion.
310 If this assertion triggers, it means that there is a new TS_*
311 structure that should be handled by the streamer. */
312 for (i
= 0; i
< LAST_TS_ENUM
; i
++)
313 gcc_assert (handled_p
[i
]);
317 /* Helper for lto_streamer_cache_insert_1. Add T to CACHE->NODES at
321 lto_streamer_cache_add_to_node_array (struct lto_streamer_cache_d
*cache
,
324 /* Make sure we're either replacing an old element or
325 appending consecutively. */
326 gcc_assert (ix
<= VEC_length (tree
, cache
->nodes
));
328 if (ix
== VEC_length (tree
, cache
->nodes
))
329 VEC_safe_push (tree
, heap
, cache
->nodes
, t
);
331 VEC_replace (tree
, cache
->nodes
, ix
, t
);
335 /* Helper for lto_streamer_cache_insert and lto_streamer_cache_insert_at.
336 CACHE, T, and IX_P are as in lto_streamer_cache_insert.
338 If INSERT_AT_NEXT_SLOT_P is true, T is inserted at the next available
339 slot in the cache. Otherwise, T is inserted at the position indicated
342 If T already existed in CACHE, return true. Otherwise,
346 lto_streamer_cache_insert_1 (struct lto_streamer_cache_d
*cache
,
347 tree t
, unsigned *ix_p
,
348 bool insert_at_next_slot_p
)
351 struct tree_int_map d_entry
, *entry
;
357 d_entry
.base
.from
= t
;
358 slot
= htab_find_slot (cache
->node_map
, &d_entry
, INSERT
);
361 /* Determine the next slot to use in the cache. */
362 if (insert_at_next_slot_p
)
363 ix
= VEC_length (tree
, cache
->nodes
);
367 entry
= (struct tree_int_map
*)pool_alloc (cache
->node_map_entries
);
368 entry
->base
.from
= t
;
372 lto_streamer_cache_add_to_node_array (cache
, ix
, t
);
374 /* Indicate that the item was not present in the cache. */
379 entry
= (struct tree_int_map
*) *slot
;
382 if (!insert_at_next_slot_p
&& ix
!= *ix_p
)
384 /* If the caller wants to insert T at a specific slot
385 location, and ENTRY->TO does not match *IX_P, add T to
386 the requested location slot. */
388 lto_streamer_cache_add_to_node_array (cache
, ix
, t
);
391 /* Indicate that T was already in the cache. */
402 /* Insert tree node T in CACHE. If T already existed in the cache
403 return true. Otherwise, return false.
405 If IX_P is non-null, update it with the index into the cache where
406 T has been stored. */
409 lto_streamer_cache_insert (struct lto_streamer_cache_d
*cache
, tree t
,
412 return lto_streamer_cache_insert_1 (cache
, t
, ix_p
, true);
416 /* Insert tree node T in CACHE at slot IX. If T already
417 existed in the cache return true. Otherwise, return false. */
420 lto_streamer_cache_insert_at (struct lto_streamer_cache_d
*cache
,
423 return lto_streamer_cache_insert_1 (cache
, t
, &ix
, false);
427 /* Appends tree node T to CACHE, even if T already existed in it. */
430 lto_streamer_cache_append (struct lto_streamer_cache_d
*cache
, tree t
)
432 unsigned ix
= VEC_length (tree
, cache
->nodes
);
433 lto_streamer_cache_insert_1 (cache
, t
, &ix
, false);
436 /* Return true if tree node T exists in CACHE, otherwise false. If IX_P is
437 not NULL, write to *IX_P the index into the cache where T is stored
438 ((unsigned)-1 if T is not found). */
441 lto_streamer_cache_lookup (struct lto_streamer_cache_d
*cache
, tree t
,
445 struct tree_int_map d_slot
;
451 d_slot
.base
.from
= t
;
452 slot
= htab_find_slot (cache
->node_map
, &d_slot
, NO_INSERT
);
461 ix
= ((struct tree_int_map
*) *slot
)->to
;
471 /* Return the tree node at slot IX in CACHE. */
474 lto_streamer_cache_get (struct lto_streamer_cache_d
*cache
, unsigned ix
)
478 /* Make sure we're not requesting something we don't have. */
479 gcc_assert (ix
< VEC_length (tree
, cache
->nodes
));
481 return VEC_index (tree
, cache
->nodes
, ix
);
485 /* Record NODE in COMMON_NODES if it is not NULL and is not already in
489 lto_record_common_node (tree
*nodep
, VEC(tree
, heap
) **common_nodes
,
490 struct pointer_set_t
*seen_nodes
)
494 if (node
== NULL_TREE
)
499 /* Type merging will get confused by the canonical types as they
500 are set by the middle-end. */
502 TYPE_CANONICAL (node
) = NULL_TREE
;
503 node
= gimple_register_type (node
);
504 TYPE_CANONICAL (node
) = gimple_register_canonical_type (node
);
506 TYPE_CANONICAL (*nodep
) = TYPE_CANONICAL (node
);
510 /* Return if node is already seen. */
511 if (pointer_set_insert (seen_nodes
, node
))
514 VEC_safe_push (tree
, heap
, *common_nodes
, node
);
516 if (POINTER_TYPE_P (node
)
517 || TREE_CODE (node
) == COMPLEX_TYPE
518 || TREE_CODE (node
) == ARRAY_TYPE
)
519 lto_record_common_node (&TREE_TYPE (node
), common_nodes
, seen_nodes
);
523 /* Generate a vector of common nodes and make sure they are merged
524 properly according to the gimple type table. */
526 static VEC(tree
,heap
) *
527 lto_get_common_nodes (void)
530 VEC(tree
,heap
) *common_nodes
= NULL
;
531 struct pointer_set_t
*seen_nodes
;
533 /* The MAIN_IDENTIFIER_NODE is normally set up by the front-end, but the
534 LTO back-end must agree. Currently, the only languages that set this
535 use the name "main". */
536 if (main_identifier_node
)
538 const char *main_name
= IDENTIFIER_POINTER (main_identifier_node
);
539 gcc_assert (strcmp (main_name
, "main") == 0);
542 main_identifier_node
= get_identifier ("main");
544 gcc_assert (ptrdiff_type_node
== integer_type_node
);
546 /* FIXME lto. In the C++ front-end, fileptr_type_node is defined as a
547 variant copy of of ptr_type_node, rather than ptr_node itself. The
548 distinction should only be relevant to the front-end, so we always
549 use the C definition here in lto1.
551 These should be assured in pass_ipa_free_lang_data. */
552 gcc_assert (fileptr_type_node
== ptr_type_node
);
553 gcc_assert (TYPE_MAIN_VARIANT (fileptr_type_node
) == ptr_type_node
);
555 seen_nodes
= pointer_set_create ();
557 /* Skip itk_char. char_type_node is shared with the appropriately
559 for (i
= itk_signed_char
; i
< itk_none
; i
++)
560 lto_record_common_node (&integer_types
[i
], &common_nodes
, seen_nodes
);
562 for (i
= 0; i
< TYPE_KIND_LAST
; i
++)
563 lto_record_common_node (&sizetype_tab
[i
], &common_nodes
, seen_nodes
);
565 for (i
= 0; i
< TI_MAX
; i
++)
566 lto_record_common_node (&global_trees
[i
], &common_nodes
, seen_nodes
);
568 pointer_set_destroy (seen_nodes
);
574 /* Assign an index to tree node T and enter it in the streamer cache
578 preload_common_node (struct lto_streamer_cache_d
*cache
, tree t
)
582 lto_streamer_cache_insert (cache
, t
, NULL
);
584 /* The FIELD_DECLs of structures should be shared, so that every
585 COMPONENT_REF uses the same tree node when referencing a field.
586 Pointer equality between FIELD_DECLs is used by the alias
587 machinery to compute overlapping memory references (See
588 nonoverlapping_component_refs_p). */
589 if (TREE_CODE (t
) == RECORD_TYPE
)
593 for (f
= TYPE_FIELDS (t
); f
; f
= TREE_CHAIN (f
))
594 preload_common_node (cache
, f
);
599 /* Create a cache of pickled nodes. */
601 struct lto_streamer_cache_d
*
602 lto_streamer_cache_create (void)
604 struct lto_streamer_cache_d
*cache
;
605 VEC(tree
, heap
) *common_nodes
;
609 cache
= XCNEW (struct lto_streamer_cache_d
);
611 cache
->node_map
= htab_create (101, tree_int_map_hash
, tree_int_map_eq
, NULL
);
613 cache
->node_map_entries
= create_alloc_pool ("node map",
614 sizeof (struct tree_int_map
),
617 /* Load all the well-known tree nodes that are always created by
618 the compiler on startup. This prevents writing them out
620 common_nodes
= lto_get_common_nodes ();
622 FOR_EACH_VEC_ELT (tree
, common_nodes
, i
, node
)
623 preload_common_node (cache
, node
);
625 VEC_free(tree
, heap
, common_nodes
);
631 /* Delete the streamer cache C. */
634 lto_streamer_cache_delete (struct lto_streamer_cache_d
*c
)
639 htab_delete (c
->node_map
);
640 free_alloc_pool (c
->node_map_entries
);
641 VEC_free (tree
, heap
, c
->nodes
);
646 #ifdef LTO_STREAMER_DEBUG
647 static htab_t tree_htab
;
649 struct tree_hash_entry
656 hash_tree (const void *p
)
658 const struct tree_hash_entry
*e
= (const struct tree_hash_entry
*) p
;
659 return htab_hash_pointer (e
->key
);
663 eq_tree (const void *p1
, const void *p2
)
665 const struct tree_hash_entry
*e1
= (const struct tree_hash_entry
*) p1
;
666 const struct tree_hash_entry
*e2
= (const struct tree_hash_entry
*) p2
;
667 return (e1
->key
== e2
->key
);
671 /* Initialization common to the LTO reader and writer. */
674 lto_streamer_init (void)
676 /* Check that all the TS_* handled by the reader and writer routines
677 match exactly the structures defined in treestruct.def. When a
678 new TS_* astructure is added, the streamer should be updated to
680 check_handled_ts_structures ();
682 #ifdef LTO_STREAMER_DEBUG
683 tree_htab
= htab_create (31, hash_tree
, eq_tree
, NULL
);
688 /* Gate function for all LTO streaming passes. */
693 return ((flag_generate_lto
|| in_lto_p
)
694 /* Don't bother doing anything if the program has errors. */
699 #ifdef LTO_STREAMER_DEBUG
700 /* Add a mapping between T and ORIG_T, which is the numeric value of
701 the original address of T as it was seen by the LTO writer. This
702 mapping is useful when debugging streaming problems. A debugging
703 session can be started on both reader and writer using ORIG_T
704 as a breakpoint value in both sessions.
706 Note that this mapping is transient and only valid while T is
707 being reconstructed. Once T is fully built, the mapping is
711 lto_orig_address_map (tree t
, intptr_t orig_t
)
713 struct tree_hash_entry ent
;
714 struct tree_hash_entry
**slot
;
719 = (struct tree_hash_entry
**) htab_find_slot (tree_htab
, &ent
, INSERT
);
721 *slot
= XNEW (struct tree_hash_entry
);
726 /* Get the original address of T as it was seen by the writer. This
727 is only valid while T is being reconstructed. */
730 lto_orig_address_get (tree t
)
732 struct tree_hash_entry ent
;
733 struct tree_hash_entry
**slot
;
737 = (struct tree_hash_entry
**) htab_find_slot (tree_htab
, &ent
, NO_INSERT
);
738 return (slot
? (*slot
)->value
: 0);
742 /* Clear the mapping of T to its original address. */
745 lto_orig_address_remove (tree t
)
747 struct tree_hash_entry ent
;
748 struct tree_hash_entry
**slot
;
752 = (struct tree_hash_entry
**) htab_find_slot (tree_htab
, &ent
, NO_INSERT
);
755 htab_clear_slot (tree_htab
, (PTR
*)slot
);
760 /* Check that the version MAJOR.MINOR is the correct version number. */
763 lto_check_version (int major
, int minor
)
765 if (major
!= LTO_major_version
|| minor
!= LTO_minor_version
)
766 fatal_error ("bytecode stream generated with LTO version %d.%d instead "
767 "of the expected %d.%d",
769 LTO_major_version
, LTO_minor_version
);