1 /* Data structures and declarations used for reading and writing
2 GIMPLE to a file stream.
4 Copyright (C) 2009, 2010, 2011 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/>. */
23 #ifndef GCC_LTO_STREAMER_H
24 #define GCC_LTO_STREAMER_H
26 #include "plugin-api.h"
33 #include "alloc-pool.h"
36 /* Define when debugging the LTO streamer. This causes the writer
37 to output the numeric value for the memory address of the tree node
38 being emitted. When debugging a problem in the reader, check the
39 original address that the writer was emitting using lto_orig_address_get.
40 With this value, set a breakpoint in the writer (e.g., lto_output_tree)
41 to trace how the faulty node is being emitted. */
42 /* #define LTO_STREAMER_DEBUG 1 */
44 /* The encoding for a function consists of the following sections:
52 7) Names for the labels that have names
54 9) The control flow graph.
55 10-11)Gimple for local decls.
56 12) Gimple for the function.
60 2-6) THE GLOBAL DECLS AND TYPES.
62 The global decls and types are encoded in the same way. For each
63 entry, there is word with the offset within the section to the
68 Since most labels do not have names, this section my be of zero
69 length. It consists of an array of string table references, one
70 per label. In the lto code, the labels are given either
71 positive or negative indexes. the positive ones have names and
72 the negative ones do not. The positive index can be used to
73 find the name in this array.
77 10) Index into the local decls. Since local decls can have local
78 decls inside them, they must be read in randomly in order to
79 properly restore them.
81 11-12) GIMPLE FOR THE LOCAL DECLS AND THE FUNCTION BODY.
83 The gimple consists of a set of records.
87 At the top level of (8) is the function. It consists of five
90 LTO_function - The tag.
91 eh tree - This is all of the exception handling regions
92 put out in a post order traversial of the
93 tree. Siblings are output as lists terminated
94 by a 0. The set of fields matches the fields
97 last_basic_block - in uleb128 form.
99 basic blocks - This is the set of basic blocks.
101 zero - The termination of the basic blocks.
105 There are two forms of basic blocks depending on if they are
108 The basic block consists of:
110 LTO_bb1 or LTO_bb0 - The tag.
112 bb->index - the index in uleb128 form.
114 #succs - The number of successors un uleb128 form.
116 the successors - For each edge, a pair. The first of the
117 pair is the index of the successor in
118 uleb128 form and the second are the flags in
121 the statements - A gimple tree, as described above.
122 These are only present for LTO_BB1.
123 Following each statement is an optional
124 exception handling record LTO_eh_region
125 which contains the region number (for
128 zero - This is only present for LTO_BB1 and is used
129 to terminate the statements and exception
130 regions within this block.
134 String are represented in the table as pairs, a length in ULEB128
135 form followed by the data for the string. */
137 /* The string that is the prefix on the section names we make for lto.
138 For decls the DECL_ASSEMBLER_NAME is appended to make the section
139 name for the functions and static_initializers. For other types of
140 sections a '.' and the section type are appended. */
141 #define LTO_SECTION_NAME_PREFIX ".gnu.lto_"
143 #define LTO_major_version 2
144 #define LTO_minor_version 0
146 typedef unsigned char lto_decl_flags_t;
149 /* Data structures used to pack values and bitflags into a vector of
150 words. Used to stream values of a fixed number of bits in a space
152 static unsigned const BITS_PER_BITPACK_WORD = HOST_BITS_PER_WIDE_INT;
154 typedef unsigned HOST_WIDE_INT bitpack_word_t;
155 DEF_VEC_I(bitpack_word_t);
156 DEF_VEC_ALLOC_I(bitpack_word_t, heap);
160 /* The position of the first unused or unconsumed bit in the word. */
163 /* The current word we are (un)packing. */
166 /* The lto_output_stream or the lto_input_block we are streaming to/from. */
170 /* Tags representing the various IL objects written to the bytecode file
171 (GIMPLE statements, basic blocks, EH regions, tree nodes, etc).
173 NOTE, when adding new LTO tags, also update lto_tag_name. */
178 /* Reserve enough entries to fit all the tree and gimple codes handled
179 by the streamer. This guarantees that:
181 1- Given a tree code C:
182 enum LTO_tags tag == C + 1
184 2- Given a gimple code C:
185 enum LTO_tags tag == C + NUM_TREE_CODES + 1
187 Conversely, to map between LTO tags and tree/gimple codes, the
188 reverse operation must be applied. */
189 LTO_bb0 = 1 + NUM_TREE_CODES + LAST_AND_UNUSED_GIMPLE_CODE,
192 /* EH region holding the previous statement. */
195 /* An MD or NORMAL builtin. Only the code and class are streamed out. */
204 /* EH region types. These mirror enum eh_region_type. */
207 LTO_ert_allowed_exceptions,
208 LTO_ert_must_not_throw,
210 /* EH landing pad. */
213 /* EH try/catch node. */
216 /* Special for global streamer. Reference to previously-streamed node. */
217 LTO_tree_pickle_reference,
219 /* References to indexable tree nodes. These objects are stored in
220 tables that are written separately from the function bodies that
221 reference them. This way they can be instantiated even when the
222 referencing functions aren't (e.g., during WPA) and it also allows
223 functions to be copied from one file to another without having
224 to unpickle the body first (the references are location
227 NOTE, do not regroup these values as the grouping is exposed
228 in the range checks done in lto_input_tree. */
229 LTO_field_decl_ref, /* Do not change. */
230 LTO_function_decl_ref,
232 LTO_namespace_decl_ref,
238 LTO_imported_decl_ref,
239 LTO_translation_unit_decl_ref,
240 LTO_global_decl_ref, /* Do not change. */
242 /* This tag must always be last. */
247 /* Set of section types that are in an LTO file. This list will grow
248 as the number of IPA passes grows since each IPA pass will need its
249 own section type to store its summary information.
251 When adding a new section type, you must also extend the
252 LTO_SECTION_NAME array in lto-section-in.c. */
253 enum lto_section_type
255 LTO_section_decls = 0,
256 LTO_section_function_body,
257 LTO_section_static_initializer,
261 LTO_section_jump_functions,
262 LTO_section_ipa_pure_const,
263 LTO_section_ipa_reference,
266 LTO_section_cgraph_opt_sum,
267 LTO_section_inline_summary,
268 LTO_N_SECTION_TYPES /* Must be last. */
271 /* Indices to the various function, type and symbol streams. */
274 LTO_DECL_STREAM_TYPE = 0, /* Must be first. */
275 LTO_DECL_STREAM_FIELD_DECL,
276 LTO_DECL_STREAM_FN_DECL,
277 LTO_DECL_STREAM_VAR_DECL,
278 LTO_DECL_STREAM_TYPE_DECL,
279 LTO_DECL_STREAM_NAMESPACE_DECL,
280 LTO_DECL_STREAM_LABEL_DECL,
282 } lto_decl_stream_e_t;
284 typedef enum ld_plugin_symbol_resolution ld_plugin_symbol_resolution_t;
285 DEF_VEC_I(ld_plugin_symbol_resolution_t);
286 DEF_VEC_ALLOC_I(ld_plugin_symbol_resolution_t, heap);
289 /* Macro to define convenience functions for type and decl streams
290 in lto_file_decl_data. */
291 #define DEFINE_DECL_STREAM_FUNCS(UPPER_NAME, name) \
293 lto_file_decl_data_get_ ## name (struct lto_file_decl_data *data, \
296 struct lto_in_decl_state *state = data->current_decl_state; \
297 gcc_assert (idx < state->streams[LTO_DECL_STREAM_## UPPER_NAME].size); \
298 return state->streams[LTO_DECL_STREAM_## UPPER_NAME].trees[idx]; \
301 static inline unsigned int \
302 lto_file_decl_data_num_ ## name ## s (struct lto_file_decl_data *data) \
304 struct lto_in_decl_state *state = data->current_decl_state; \
305 return state->streams[LTO_DECL_STREAM_## UPPER_NAME].size; \
309 /* Return a char pointer to the start of a data stream for an lto pass
310 or function. The first parameter is the file data that contains
311 the information. The second parameter is the type of information
312 to be obtained. The third parameter is the name of the function
313 and is only used when finding a function body; otherwise it is
314 NULL. The fourth parameter is the length of the data returned. */
315 typedef const char* (lto_get_section_data_f) (struct lto_file_decl_data *,
316 enum lto_section_type,
320 /* Return the data found from the above call. The first three
321 parameters are the same as above. The fourth parameter is the data
322 itself and the fifth is the lenght of the data. */
323 typedef void (lto_free_section_data_f) (struct lto_file_decl_data *,
324 enum lto_section_type,
329 /* Cache of pickled nodes. Used to avoid writing the same node more
330 than once. The first time a tree node is streamed out, it is
331 entered in this cache. Subsequent references to the same node are
332 resolved by looking it up in this cache.
334 This is used in two ways:
336 - On the writing side, the first time T is added to STREAMER_CACHE,
337 a new reference index is created for T and T is emitted on the
338 stream. If T needs to be emitted again to the stream, instead of
339 pickling it again, the reference index is emitted.
341 - On the reading side, the first time T is read from the stream, it
342 is reconstructed in memory and a new reference index created for
343 T. The reconstructed T is inserted in some array so that when
344 the reference index for T is found in the input stream, it can be
345 used to look up into the array to get the reconstructed T. */
346 struct lto_streamer_cache_d
348 /* The mapping between tree nodes and slots into the nodes array. */
349 struct pointer_map_t *node_map;
351 /* The nodes pickled so far. */
352 VEC(tree,heap) *nodes;
356 /* Structure used as buffer for reading an LTO file. */
357 struct lto_input_block
364 #define LTO_INIT_INPUT_BLOCK(BASE,D,P,L) \
371 #define LTO_INIT_INPUT_BLOCK_PTR(BASE,D,P,L) \
379 /* The is the first part of the record for a function or constructor
383 int16_t major_version;
384 int16_t minor_version;
385 enum lto_section_type section_type;
388 /* The header for a function body. */
389 struct lto_function_header
391 /* The header for all types of sections. */
392 struct lto_header lto_header;
394 /* Number of labels with names. */
395 int32_t num_named_labels;
397 /* Number of labels without names. */
398 int32_t num_unnamed_labels;
400 /* Size compressed or 0 if not compressed. */
401 int32_t compressed_size;
403 /* Size of names for named labels. */
404 int32_t named_label_size;
406 /* Size of the cfg. */
409 /* Size of main gimple body of function. */
412 /* Size of the string table. */
417 /* Structure describing a symbol section. */
418 struct lto_decl_header
420 /* The header for all types of sections. */
421 struct lto_header lto_header;
423 /* Size of region for decl state. */
424 int32_t decl_state_size;
426 /* Number of nodes in globals stream. */
429 /* Size of region for expressions, decls, types, etc. */
432 /* Size of the string table. */
437 /* Statistics gathered during LTO, WPA and LTRANS. */
440 unsigned HOST_WIDE_INT num_input_cgraph_nodes;
441 unsigned HOST_WIDE_INT num_output_cgraph_nodes;
442 unsigned HOST_WIDE_INT num_input_files;
443 unsigned HOST_WIDE_INT num_output_files;
444 unsigned HOST_WIDE_INT num_cgraph_partitions;
445 unsigned HOST_WIDE_INT section_size[LTO_N_SECTION_TYPES];
446 unsigned HOST_WIDE_INT num_function_bodies;
447 unsigned HOST_WIDE_INT num_trees[NUM_TREE_CODES];
448 unsigned HOST_WIDE_INT num_output_il_bytes;
449 unsigned HOST_WIDE_INT num_compressed_il_bytes;
450 unsigned HOST_WIDE_INT num_input_il_bytes;
451 unsigned HOST_WIDE_INT num_uncompressed_il_bytes;
454 /* Encoder data structure used to stream callgraph nodes. */
455 struct lto_cgraph_encoder_d
457 /* Map nodes to reference number. */
458 struct pointer_map_t *map;
460 /* Map reference number to node. */
461 VEC(cgraph_node_ptr,heap) *nodes;
463 /* Map of nodes where we want to output body. */
464 struct pointer_set_t *body;
467 typedef struct lto_cgraph_encoder_d *lto_cgraph_encoder_t;
469 /* Return number of encoded nodes in ENCODER. */
472 lto_cgraph_encoder_size (lto_cgraph_encoder_t encoder)
474 return VEC_length (cgraph_node_ptr, encoder->nodes);
478 /* Encoder data structure used to stream callgraph nodes. */
479 struct lto_varpool_encoder_d
481 /* Map nodes to reference number. */
482 struct pointer_map_t *map;
484 /* Map reference number to node. */
485 VEC(varpool_node_ptr,heap) *nodes;
487 /* Map of nodes where we want to output initializer. */
488 struct pointer_set_t *initializer;
490 typedef struct lto_varpool_encoder_d *lto_varpool_encoder_t;
492 /* Return number of encoded nodes in ENCODER. */
495 lto_varpool_encoder_size (lto_varpool_encoder_t encoder)
497 return VEC_length (varpool_node_ptr, encoder->nodes);
500 /* Mapping from indices to trees. */
501 struct GTY(()) lto_tree_ref_table
503 /* Array of referenced trees . */
504 tree * GTY((length ("%h.size"))) trees;
511 /* Mapping between trees and slots in an array. */
519 /* The lto_tree_ref_encoder struct is used to encode trees into indices. */
521 struct lto_tree_ref_encoder
523 htab_t tree_hash_table; /* Maps pointers to indices. */
524 unsigned int next_index; /* Next available index. */
525 VEC(tree,heap) *trees; /* Maps indices to pointers. */
529 /* Structure to hold states of input scope. */
530 struct GTY(()) lto_in_decl_state
532 /* Array of lto_in_decl_buffers to store type and decls streams. */
533 struct lto_tree_ref_table streams[LTO_N_DECL_STREAMS];
535 /* If this in-decl state is associated with a function. FN_DECL
536 point to the FUNCTION_DECL. */
540 typedef struct lto_in_decl_state *lto_in_decl_state_ptr;
543 /* The structure that holds all of the vectors of global types,
544 decls and cgraph nodes used in the serialization of this file. */
545 struct lto_out_decl_state
547 /* The buffers contain the sets of decls of various kinds and types we have
548 seen so far and the indexes assigned to them. */
549 struct lto_tree_ref_encoder streams[LTO_N_DECL_STREAMS];
551 /* Encoder for cgraph nodes. */
552 lto_cgraph_encoder_t cgraph_node_encoder;
554 /* Encoder for varpool nodes. */
555 lto_varpool_encoder_t varpool_node_encoder;
557 /* If this out-decl state belongs to a function, fn_decl points to that
558 function. Otherwise, it is NULL. */
562 typedef struct lto_out_decl_state *lto_out_decl_state_ptr;
564 DEF_VEC_P(lto_out_decl_state_ptr);
565 DEF_VEC_ALLOC_P(lto_out_decl_state_ptr, heap);
567 /* One of these is allocated for each object file that being compiled
568 by lto. This structure contains the tables that are needed by the
569 serialized functions and ipa passes to connect themselves to the
570 global types and decls as they are reconstituted. */
571 struct GTY(()) lto_file_decl_data
573 /* Decl state currently used. */
574 struct lto_in_decl_state *current_decl_state;
576 /* Decl state corresponding to regions outside of any functions
577 in the compilation unit. */
578 struct lto_in_decl_state *global_decl_state;
580 /* Table of cgraph nodes present in this file. */
581 lto_cgraph_encoder_t GTY((skip)) cgraph_node_encoder;
583 /* Table of varpool nodes present in this file. */
584 lto_varpool_encoder_t GTY((skip)) varpool_node_encoder;
586 /* Hash table maps lto-related section names to location in file. */
587 htab_t GTY((param_is (struct lto_in_decl_state))) function_decl_states;
589 /* The .o file that these offsets relate to. */
590 const char *GTY((skip)) file_name;
592 /* Hash table maps lto-related section names to location in file. */
593 htab_t GTY((skip)) section_hash_table;
595 /* Hash new name of renamed global declaration to its original name. */
596 htab_t GTY((skip)) renaming_hash_table;
598 /* Linked list used temporarily in reader */
599 struct lto_file_decl_data *next;
601 /* Sub ID for merged objects. */
604 /* Symbol resolutions for this file */
605 VEC(ld_plugin_symbol_resolution_t,heap) * GTY((skip)) resolutions;
607 struct gcov_ctr_summary GTY((skip)) profile_info;
610 typedef struct lto_file_decl_data *lto_file_decl_data_ptr;
612 struct lto_char_ptr_base
617 /* An incore byte stream to buffer the various parts of the function.
618 The entire structure should be zeroed when created. The record
619 consists of a set of blocks. The first sizeof (ptr) bytes are used
620 as a chain, and the rest store the bytes to be written. */
621 struct lto_output_stream
623 /* The pointer to the first block in the stream. */
624 struct lto_char_ptr_base * first_block;
626 /* The pointer to the last and current block in the stream. */
627 struct lto_char_ptr_base * current_block;
629 /* The pointer to where the next char should be written. */
630 char * current_pointer;
632 /* The number of characters left in the current block. */
633 unsigned int left_in_block;
635 /* The block size of the last block allocated. */
636 unsigned int block_size;
638 /* The total number of characters written. */
639 unsigned int total_size;
642 /* The is the first part of the record in an LTO file for many of the
644 struct lto_simple_header
646 /* The header for all types of sections. */
647 struct lto_header lto_header;
649 /* Size of main gimple body of function. */
652 /* Size of main stream when compressed. */
653 int32_t compressed_size;
656 /* A simple output block. This can be used for simple IPA passes that
657 do not need more than one stream. */
658 struct lto_simple_output_block
660 enum lto_section_type section_type;
661 struct lto_out_decl_state *decl_state;
663 /* The stream that the main tree codes are written to. */
664 struct lto_output_stream *main_stream;
667 /* Data structure holding all the data and descriptors used when writing
671 enum lto_section_type section_type;
672 struct lto_out_decl_state *decl_state;
674 /* The stream that the main tree codes are written to. */
675 struct lto_output_stream *main_stream;
677 /* The stream that contains the string table. */
678 struct lto_output_stream *string_stream;
680 /* The stream that contains the cfg. */
681 struct lto_output_stream *cfg_stream;
683 /* The hash table that contains the set of strings we have seen so
684 far and the indexes assigned to them. */
685 htab_t string_hash_table;
687 /* The current cgraph_node that we are currently serializing. Null
688 if we are serializing something else. */
689 struct cgraph_node *cgraph_node;
691 /* These are the last file and line that were seen in the stream.
692 If the current node differs from these, it needs to insert
693 something into the stream and fix these up. */
694 const char *current_file;
698 /* True if writing globals and types. */
701 /* Cache of nodes written in this section. */
702 struct lto_streamer_cache_d *writer_cache;
706 /* Data and descriptors used when reading from an LTO file. */
709 /* The global decls and types. */
710 struct lto_file_decl_data *file_data;
712 /* All of the labels. */
715 /* The string table. */
718 /* The length of the string table. */
719 unsigned int strings_len;
721 /* Number of named labels. Used to find the index of unnamed labels
722 since they share space with the named labels. */
723 unsigned int num_named_labels;
725 /* Number of unnamed labels. */
726 unsigned int num_unnamed_labels;
728 const char *current_file;
732 /* Maps each reference number to the resolution done by the linker. */
733 VEC(ld_plugin_symbol_resolution_t,heap) *globals_resolution;
735 /* Cache of pickled nodes. */
736 struct lto_streamer_cache_d *reader_cache;
740 /* In lto-section-in.c */
741 extern struct lto_input_block * lto_create_simple_input_block (
742 struct lto_file_decl_data *,
743 enum lto_section_type, const char **, size_t *);
745 lto_destroy_simple_input_block (struct lto_file_decl_data *,
746 enum lto_section_type,
747 struct lto_input_block *, const char *, size_t);
748 extern void lto_set_in_hooks (struct lto_file_decl_data **,
749 lto_get_section_data_f *,
750 lto_free_section_data_f *);
751 extern struct lto_file_decl_data **lto_get_file_decl_data (void);
752 extern const char *lto_get_section_data (struct lto_file_decl_data *,
753 enum lto_section_type,
754 const char *, size_t *);
755 extern void lto_free_section_data (struct lto_file_decl_data *,
756 enum lto_section_type,
757 const char *, const char *, size_t);
758 extern unsigned HOST_WIDE_INT lto_input_uleb128 (struct lto_input_block *);
759 extern unsigned HOST_WIDEST_INT lto_input_widest_uint_uleb128 (
760 struct lto_input_block *);
761 extern HOST_WIDE_INT lto_input_sleb128 (struct lto_input_block *);
762 extern htab_t lto_create_renaming_table (void);
763 extern void lto_record_renamed_decl (struct lto_file_decl_data *,
764 const char *, const char *);
765 extern const char *lto_get_decl_name_mapping (struct lto_file_decl_data *,
767 extern struct lto_in_decl_state *lto_new_in_decl_state (void);
768 extern void lto_delete_in_decl_state (struct lto_in_decl_state *);
769 extern hashval_t lto_hash_in_decl_state (const void *);
770 extern int lto_eq_in_decl_state (const void *, const void *);
771 extern struct lto_in_decl_state *lto_get_function_in_decl_state (
772 struct lto_file_decl_data *, tree);
773 extern void lto_section_overrun (struct lto_input_block *) ATTRIBUTE_NORETURN;
774 extern void lto_value_range_error (const char *,
775 HOST_WIDE_INT, HOST_WIDE_INT,
776 HOST_WIDE_INT) ATTRIBUTE_NORETURN;
777 extern void bp_pack_var_len_unsigned (struct bitpack_d *, unsigned HOST_WIDE_INT);
778 extern void bp_pack_var_len_int (struct bitpack_d *, HOST_WIDE_INT);
779 extern unsigned HOST_WIDE_INT bp_unpack_var_len_unsigned (struct bitpack_d *);
780 extern HOST_WIDE_INT bp_unpack_var_len_int (struct bitpack_d *);
782 /* In lto-section-out.c */
783 extern hashval_t lto_hash_decl_slot_node (const void *);
784 extern int lto_eq_decl_slot_node (const void *, const void *);
785 extern hashval_t lto_hash_type_slot_node (const void *);
786 extern int lto_eq_type_slot_node (const void *, const void *);
787 extern void lto_begin_section (const char *, bool);
788 extern void lto_end_section (void);
789 extern void lto_write_stream (struct lto_output_stream *);
790 extern void lto_output_data_stream (struct lto_output_stream *, const void *,
792 extern void lto_output_uleb128_stream (struct lto_output_stream *,
793 unsigned HOST_WIDE_INT);
794 extern void lto_output_widest_uint_uleb128_stream (struct lto_output_stream *,
795 unsigned HOST_WIDEST_INT);
796 extern void lto_output_sleb128_stream (struct lto_output_stream *,
798 extern bool lto_output_decl_index (struct lto_output_stream *,
799 struct lto_tree_ref_encoder *,
800 tree, unsigned int *);
801 extern void lto_output_field_decl_index (struct lto_out_decl_state *,
802 struct lto_output_stream *, tree);
803 extern void lto_output_fn_decl_index (struct lto_out_decl_state *,
804 struct lto_output_stream *, tree);
805 extern void lto_output_namespace_decl_index (struct lto_out_decl_state *,
806 struct lto_output_stream *, tree);
807 extern void lto_output_var_decl_index (struct lto_out_decl_state *,
808 struct lto_output_stream *, tree);
809 extern void lto_output_type_decl_index (struct lto_out_decl_state *,
810 struct lto_output_stream *, tree);
811 extern void lto_output_type_ref_index (struct lto_out_decl_state *,
812 struct lto_output_stream *, tree);
813 extern struct lto_simple_output_block *lto_create_simple_output_block (
814 enum lto_section_type);
815 extern void lto_destroy_simple_output_block (struct lto_simple_output_block *);
816 extern struct lto_out_decl_state *lto_new_out_decl_state (void);
817 extern void lto_delete_out_decl_state (struct lto_out_decl_state *);
818 extern struct lto_out_decl_state *lto_get_out_decl_state (void);
819 extern void lto_push_out_decl_state (struct lto_out_decl_state *);
820 extern struct lto_out_decl_state *lto_pop_out_decl_state (void);
821 extern void lto_record_function_out_decl_state (tree,
822 struct lto_out_decl_state *);
823 extern void lto_append_block (struct lto_output_stream *);
826 /* In lto-streamer.c. */
827 extern const char *lto_tag_name (enum LTO_tags);
828 extern bitmap lto_bitmap_alloc (void);
829 extern void lto_bitmap_free (bitmap);
830 extern char *lto_get_section_name (int, const char *, struct lto_file_decl_data *);
831 extern void print_lto_report (void);
832 extern bool lto_streamer_cache_insert (struct lto_streamer_cache_d *, tree,
834 extern bool lto_streamer_cache_insert_at (struct lto_streamer_cache_d *, tree,
836 extern void lto_streamer_cache_append (struct lto_streamer_cache_d *, tree);
837 extern bool lto_streamer_cache_lookup (struct lto_streamer_cache_d *, tree,
839 extern tree lto_streamer_cache_get (struct lto_streamer_cache_d *, unsigned);
840 extern struct lto_streamer_cache_d *lto_streamer_cache_create (void);
841 extern void lto_streamer_cache_delete (struct lto_streamer_cache_d *);
842 extern void lto_streamer_init (void);
843 extern bool gate_lto_out (void);
844 #ifdef LTO_STREAMER_DEBUG
845 extern void lto_orig_address_map (tree, intptr_t);
846 extern intptr_t lto_orig_address_get (tree);
847 extern void lto_orig_address_remove (tree);
849 extern void lto_check_version (int, int);
852 /* In lto-streamer-in.c */
853 extern void lto_input_cgraph (struct lto_file_decl_data *, const char *);
854 extern void lto_init_reader (void);
855 extern tree lto_input_tree (struct lto_input_block *, struct data_in *);
856 extern void lto_input_function_body (struct lto_file_decl_data *, tree,
858 extern void lto_input_constructors_and_inits (struct lto_file_decl_data *,
860 extern void lto_init_reader (void);
861 extern struct data_in *lto_data_in_create (struct lto_file_decl_data *,
862 const char *, unsigned,
863 VEC(ld_plugin_symbol_resolution_t,heap) *);
864 extern void lto_data_in_delete (struct data_in *);
865 extern const char *lto_input_string (struct data_in *,
866 struct lto_input_block *);
867 extern void lto_input_data_block (struct lto_input_block *, void *, size_t);
870 /* In lto-streamer-out.c */
871 extern void lto_register_decl_definition (tree, struct lto_file_decl_data *);
872 extern struct output_block *create_output_block (enum lto_section_type);
873 extern void destroy_output_block (struct output_block *);
874 extern void lto_output_tree (struct output_block *, tree, bool);
875 extern void produce_asm (struct output_block *ob, tree fn);
876 extern void lto_output_string (struct output_block *,
877 struct lto_output_stream *,
879 extern void lto_output_string_with_length (struct output_block *,
880 struct lto_output_stream *,
883 void lto_output_decl_state_streams (struct output_block *,
884 struct lto_out_decl_state *);
885 void lto_output_decl_state_refs (struct output_block *,
886 struct lto_output_stream *,
887 struct lto_out_decl_state *);
890 /* In lto-cgraph.c */
891 struct cgraph_node *lto_cgraph_encoder_deref (lto_cgraph_encoder_t, int);
892 int lto_cgraph_encoder_lookup (lto_cgraph_encoder_t, struct cgraph_node *);
893 lto_cgraph_encoder_t lto_cgraph_encoder_new (void);
894 int lto_cgraph_encoder_encode (lto_cgraph_encoder_t, struct cgraph_node *);
895 void lto_cgraph_encoder_delete (lto_cgraph_encoder_t);
896 bool lto_cgraph_encoder_encode_body_p (lto_cgraph_encoder_t,
897 struct cgraph_node *);
899 bool lto_varpool_encoder_encode_body_p (lto_varpool_encoder_t,
900 struct varpool_node *);
901 struct varpool_node *lto_varpool_encoder_deref (lto_varpool_encoder_t, int);
902 int lto_varpool_encoder_lookup (lto_varpool_encoder_t, struct varpool_node *);
903 lto_varpool_encoder_t lto_varpool_encoder_new (void);
904 int lto_varpool_encoder_encode (lto_varpool_encoder_t, struct varpool_node *);
905 void lto_varpool_encoder_delete (lto_varpool_encoder_t);
906 bool lto_varpool_encoder_encode_initializer_p (lto_varpool_encoder_t,
907 struct varpool_node *);
908 void output_cgraph (cgraph_node_set, varpool_node_set);
909 void input_cgraph (void);
910 bool referenced_from_other_partition_p (struct ipa_ref_list *,
912 varpool_node_set vset);
913 bool reachable_from_other_partition_p (struct cgraph_node *,
915 bool referenced_from_this_partition_p (struct ipa_ref_list *,
917 varpool_node_set vset);
918 bool reachable_from_this_partition_p (struct cgraph_node *,
920 void compute_ltrans_boundary (struct lto_out_decl_state *state,
921 cgraph_node_set, varpool_node_set);
924 /* In lto-symtab.c. */
925 extern void lto_symtab_register_decl (tree, ld_plugin_symbol_resolution_t,
926 struct lto_file_decl_data *);
927 extern void lto_symtab_merge_decls (void);
928 extern void lto_symtab_merge_cgraph_nodes (void);
929 extern tree lto_symtab_prevailing_decl (tree decl);
930 extern enum ld_plugin_symbol_resolution lto_symtab_get_resolution (tree decl);
931 extern void lto_symtab_free (void);
932 extern GTY(()) VEC(tree,gc) *lto_global_var_decls;
936 extern void lto_register_user_option (size_t, const char *, int, unsigned int);
937 extern void lto_read_file_options (struct lto_file_decl_data *);
938 extern void lto_write_options (void);
939 extern void lto_reissue_options (void);
940 void lto_clear_user_options (void);
941 void lto_clear_file_options (void);
944 /* In lto-wpa-fixup.c */
945 void lto_mark_nothrow_fndecl (tree);
946 void lto_fixup_nothrow_decls (void);
949 /* Statistics gathered during LTO, WPA and LTRANS. */
950 extern struct lto_stats_d lto_stats;
952 /* Section names corresponding to the values of enum lto_section_type. */
953 extern const char *lto_section_name[];
955 /* Holds all the out decl states of functions output so far in the
956 current output file. */
957 extern VEC(lto_out_decl_state_ptr, heap) *lto_function_decl_states;
959 /* Return true if LTO tag TAG corresponds to a tree code. */
961 lto_tag_is_tree_code_p (enum LTO_tags tag)
963 return tag > LTO_null && (unsigned) tag <= NUM_TREE_CODES;
967 /* Return true if LTO tag TAG corresponds to a gimple code. */
969 lto_tag_is_gimple_code_p (enum LTO_tags tag)
971 return (unsigned) tag >= NUM_TREE_CODES + 1
972 && (unsigned) tag < 1 + NUM_TREE_CODES + LAST_AND_UNUSED_GIMPLE_CODE;
976 /* Return the LTO tag corresponding to gimple code CODE. See enum
977 LTO_tags for details on the conversion. */
978 static inline enum LTO_tags
979 lto_gimple_code_to_tag (enum gimple_code code)
981 return (enum LTO_tags) ((unsigned) code + NUM_TREE_CODES + 1);
985 /* Return the GIMPLE code corresponding to TAG. See enum LTO_tags for
986 details on the conversion. */
987 static inline enum gimple_code
988 lto_tag_to_gimple_code (enum LTO_tags tag)
990 gcc_assert (lto_tag_is_gimple_code_p (tag));
991 return (enum gimple_code) ((unsigned) tag - NUM_TREE_CODES - 1);
995 /* Return the LTO tag corresponding to tree code CODE. See enum
996 LTO_tags for details on the conversion. */
997 static inline enum LTO_tags
998 lto_tree_code_to_tag (enum tree_code code)
1000 return (enum LTO_tags) ((unsigned) code + 1);
1004 /* Return the tree code corresponding to TAG. See enum LTO_tags for
1005 details on the conversion. */
1006 static inline enum tree_code
1007 lto_tag_to_tree_code (enum LTO_tags tag)
1009 gcc_assert (lto_tag_is_tree_code_p (tag));
1010 return (enum tree_code) ((unsigned) tag - 1);
1013 /* Initialize an lto_out_decl_buffer ENCODER. */
1015 lto_init_tree_ref_encoder (struct lto_tree_ref_encoder *encoder,
1016 htab_hash hash_fn, htab_eq eq_fn)
1018 encoder->tree_hash_table = htab_create (37, hash_fn, eq_fn, free);
1019 encoder->next_index = 0;
1020 encoder->trees = NULL;
1024 /* Destory an lto_tree_ref_encoder ENCODER by freeing its contents. The
1025 memory used by ENCODER is not freed by this function. */
1027 lto_destroy_tree_ref_encoder (struct lto_tree_ref_encoder *encoder)
1029 /* Hash table may be delete already. */
1030 if (encoder->tree_hash_table)
1031 htab_delete (encoder->tree_hash_table);
1032 VEC_free (tree, heap, encoder->trees);
1035 /* Return the number of trees encoded in ENCODER. */
1036 static inline unsigned int
1037 lto_tree_ref_encoder_size (struct lto_tree_ref_encoder *encoder)
1039 return VEC_length (tree, encoder->trees);
1042 /* Return the IDX-th tree in ENCODER. */
1044 lto_tree_ref_encoder_get_tree (struct lto_tree_ref_encoder *encoder,
1047 return VEC_index (tree, encoder->trees, idx);
1051 /* Return true if LABEL should be emitted in the global context. */
1053 emit_label_in_global_context_p (tree label)
1055 return DECL_NONLOCAL (label) || FORCED_LABEL (label);
1058 /* Return true if tree node EXPR should be streamed as a builtin. For
1059 these nodes, we just emit the class and function code. */
1061 lto_stream_as_builtin_p (tree expr)
1063 return (TREE_CODE (expr) == FUNCTION_DECL
1064 && DECL_IS_BUILTIN (expr)
1065 && (DECL_BUILT_IN_CLASS (expr) == BUILT_IN_NORMAL
1066 || DECL_BUILT_IN_CLASS (expr) == BUILT_IN_MD));
1069 /* Return true if EXPR is a tree node that can be written to disk. */
1071 lto_is_streamable (tree expr)
1073 enum tree_code code = TREE_CODE (expr);
1075 /* Notice that we reject SSA_NAMEs as well. We only emit the SSA
1076 name version in lto_output_tree_ref (see output_ssa_names). */
1077 return !is_lang_specific (expr)
1079 && code != CALL_EXPR
1080 && code != LANG_TYPE
1081 && code != MODIFY_EXPR
1082 && code != INIT_EXPR
1083 && code != TARGET_EXPR
1084 && code != BIND_EXPR
1085 && code != WITH_CLEANUP_EXPR
1086 && code != STATEMENT_LIST
1087 && (code == CASE_LABEL_EXPR
1088 || code == DECL_EXPR
1089 || TREE_CODE_CLASS (code) != tcc_statement);
1092 DEFINE_DECL_STREAM_FUNCS (TYPE, type)
1093 DEFINE_DECL_STREAM_FUNCS (FIELD_DECL, field_decl)
1094 DEFINE_DECL_STREAM_FUNCS (FN_DECL, fn_decl)
1095 DEFINE_DECL_STREAM_FUNCS (VAR_DECL, var_decl)
1096 DEFINE_DECL_STREAM_FUNCS (TYPE_DECL, type_decl)
1097 DEFINE_DECL_STREAM_FUNCS (NAMESPACE_DECL, namespace_decl)
1098 DEFINE_DECL_STREAM_FUNCS (LABEL_DECL, label_decl)
1100 /* Returns a new bit-packing context for bit-packing into S. */
1101 static inline struct bitpack_d
1102 bitpack_create (struct lto_output_stream *s)
1104 struct bitpack_d bp;
1107 bp.stream = (void *)s;
1111 /* Pack the NBITS bit sized value VAL into the bit-packing context BP. */
1113 bp_pack_value (struct bitpack_d *bp, bitpack_word_t val, unsigned nbits)
1115 bitpack_word_t word = bp->word;
1118 /* Verify that VAL fits in the NBITS. */
1119 gcc_checking_assert (nbits == BITS_PER_BITPACK_WORD
1120 || !(val & ~(((bitpack_word_t)1<<nbits)-1)));
1122 /* If val does not fit into the current bitpack word switch to the
1124 if (pos + nbits > BITS_PER_BITPACK_WORD)
1126 lto_output_uleb128_stream ((struct lto_output_stream *) bp->stream, word);
1139 /* Finishes bit-packing of BP. */
1141 lto_output_bitpack (struct bitpack_d *bp)
1143 lto_output_uleb128_stream ((struct lto_output_stream *) bp->stream,
1149 /* Returns a new bit-packing context for bit-unpacking from IB. */
1150 static inline struct bitpack_d
1151 lto_input_bitpack (struct lto_input_block *ib)
1153 struct bitpack_d bp;
1154 bp.word = lto_input_uleb128 (ib);
1156 bp.stream = (void *)ib;
1160 /* Unpacks NBITS bits from the bit-packing context BP and returns them. */
1161 static inline bitpack_word_t
1162 bp_unpack_value (struct bitpack_d *bp, unsigned nbits)
1164 bitpack_word_t mask, val;
1167 mask = (nbits == BITS_PER_BITPACK_WORD
1168 ? (bitpack_word_t) -1
1169 : ((bitpack_word_t) 1 << nbits) - 1);
1171 /* If there are not continuous nbits in the current bitpack word
1172 switch to the next one. */
1173 if (pos + nbits > BITS_PER_BITPACK_WORD)
1175 bp->word = val = lto_input_uleb128 ((struct lto_input_block *)bp->stream);
1181 bp->pos = pos + nbits;
1187 /* Write a character to the output block. */
1190 lto_output_1_stream (struct lto_output_stream *obs, char c)
1192 /* No space left. */
1193 if (obs->left_in_block == 0)
1194 lto_append_block (obs);
1196 /* Write the actual character. */
1197 *obs->current_pointer = c;
1198 obs->current_pointer++;
1200 obs->left_in_block--;
1204 /* Read byte from the input block. */
1206 static inline unsigned char
1207 lto_input_1_unsigned (struct lto_input_block *ib)
1209 if (ib->p >= ib->len)
1210 lto_section_overrun (ib);
1211 return (ib->data[ib->p++]);
1214 /* Output VAL into OBS and verify it is in range MIN...MAX that is supposed
1215 to be compile time constant.
1216 Be host independent, limit range to 31bits. */
1219 lto_output_int_in_range (struct lto_output_stream *obs,
1224 HOST_WIDE_INT range = max - min;
1226 gcc_checking_assert (val >= min && val <= max && range > 0
1227 && range < 0x7fffffff);
1230 lto_output_1_stream (obs, val & 255);
1232 lto_output_1_stream (obs, (val << 8) & 255);
1233 if (range >= 0xffff)
1234 lto_output_1_stream (obs, (val << 16) & 255);
1235 if (range >= 0xffffff)
1236 lto_output_1_stream (obs, (val << 24) & 255);
1239 /* Input VAL into OBS and verify it is in range MIN...MAX that is supposed
1240 to be compile time constant. PURPOSE is used for error reporting. */
1242 static inline HOST_WIDE_INT
1243 lto_input_int_in_range (struct lto_input_block *ib,
1244 const char *purpose,
1248 HOST_WIDE_INT range = max - min;
1249 HOST_WIDE_INT val = lto_input_1_unsigned (ib);
1251 gcc_checking_assert (range > 0 && range < 0x7fffffff);
1254 val |= ((HOST_WIDE_INT)lto_input_1_unsigned (ib)) << 8;
1255 if (range >= 0xffff)
1256 val |= ((HOST_WIDE_INT)lto_input_1_unsigned (ib)) << 16;
1257 if (range >= 0xffffff)
1258 val |= ((HOST_WIDE_INT)lto_input_1_unsigned (ib)) << 24;
1260 if (val < min || val > max)
1261 lto_value_range_error (purpose, val, min, max);
1265 /* Output VAL of type "enum enum_name" into OBS.
1266 Assume range 0...ENUM_LAST - 1. */
1267 #define lto_output_enum(obs,enum_name,enum_last,val) \
1268 lto_output_int_in_range ((obs), 0, (int)(enum_last) - 1, (int)(val))
1270 /* Input enum of type "enum enum_name" from IB.
1271 Assume range 0...ENUM_LAST - 1. */
1272 #define lto_input_enum(ib,enum_name,enum_last) \
1273 (enum enum_name)lto_input_int_in_range ((ib), #enum_name, 0, \
1274 (int)(enum_last) - 1)
1276 #endif /* GCC_LTO_STREAMER_H */