1 /* Data structures and declarations used for reading and writing
2 GIMPLE to a file stream.
4 Copyright (C) 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/>. */
23 #ifndef GCC_LTO_STREAMER_H
24 #define GCC_LTO_STREAMER_H
26 #include "plugin-api.h"
34 /* Define when debugging the LTO streamer. This causes the writer
35 to output the numeric value for the memory address of the tree node
36 being emitted. When debugging a problem in the reader, check the
37 original address that the writer was emitting using lto_orig_address_get.
38 With this value, set a breakpoint in the writer (e.g., lto_output_tree)
39 to trace how the faulty node is being emitted. */
40 /* #define LTO_STREAMER_DEBUG 1 */
42 /* The encoding for a function consists of the following sections:
50 7) Names for the labels that have names
52 9) The control flow graph.
53 10-11)Gimple for local decls.
54 12) Gimple for the function.
58 2-6) THE GLOBAL DECLS AND TYPES.
60 The global decls and types are encoded in the same way. For each
61 entry, there is word with the offset within the section to the
66 Since most labels do not have names, this section my be of zero
67 length. It consists of an array of string table references, one
68 per label. In the lto code, the labels are given either
69 positive or negative indexes. the positive ones have names and
70 the negative ones do not. The positive index can be used to
71 find the name in this array.
75 10) Index into the local decls. Since local decls can have local
76 decls inside them, they must be read in randomly in order to
77 properly restore them.
79 11-12) GIMPLE FOR THE LOCAL DECLS AND THE FUNCTION BODY.
81 The gimple consists of a set of records.
85 At the top level of (8) is the function. It consists of five
88 LTO_function - The tag.
89 eh tree - This is all of the exception handling regions
90 put out in a post order traversial of the
91 tree. Siblings are output as lists terminated
92 by a 0. The set of fields matches the fields
95 last_basic_block - in uleb128 form.
97 basic blocks - This is the set of basic blocks.
99 zero - The termination of the basic blocks.
103 There are two forms of basic blocks depending on if they are
106 The basic block consists of:
108 LTO_bb1 or LTO_bb0 - The tag.
110 bb->index - the index in uleb128 form.
112 #succs - The number of successors un uleb128 form.
114 the successors - For each edge, a pair. The first of the
115 pair is the index of the successor in
116 uleb128 form and the second are the flags in
119 the statements - A gimple tree, as described above.
120 These are only present for LTO_BB1.
121 Following each statement is an optional
122 exception handling record LTO_eh_region
123 which contains the region number (for
126 zero - This is only present for LTO_BB1 and is used
127 to terminate the statements and exception
128 regions within this block.
132 String are represented in the table as pairs, a length in ULEB128
133 form followed by the data for the string. */
135 /* The string that is the prefix on the section names we make for lto.
136 For decls the DECL_ASSEMBLER_NAME is appended to make the section
137 name for the functions and static_initializers. For other types of
138 sections a '.' and the section type are appended. */
139 #define LTO_SECTION_NAME_PREFIX ".gnu.lto_"
141 #define LTO_major_version 1
142 #define LTO_minor_version 0
144 typedef unsigned char lto_decl_flags_t;
147 /* Data structures used to pack values and bitflags into a vector of
148 words. Used to stream values of a fixed number of bits in a space
150 static unsigned const BITS_PER_BITPACK_WORD = HOST_BITS_PER_WIDE_INT;
152 typedef unsigned HOST_WIDE_INT bitpack_word_t;
153 DEF_VEC_I(bitpack_word_t);
154 DEF_VEC_ALLOC_I(bitpack_word_t, heap);
158 /* Total number of bits packed/unpacked so far. */
161 /* Values are stored contiguously, so there may be internal
162 fragmentation (words with unused bits). Therefore, we need to
163 keep track of the first available bit in the last word of the
165 size_t first_unused_bit;
167 /* Vector of words holding the packed values. */
168 VEC(bitpack_word_t, heap) *values;
171 /* Tags representing the various IL objects written to the bytecode file
172 (GIMPLE statements, basic blocks, EH regions, tree nodes, etc).
174 NOTE, when adding new LTO tags, also update lto_tag_name. */
179 /* Reserve enough entries to fit all the tree and gimple codes handled
180 by the streamer. This guarantees that:
182 1- Given a tree code C:
183 enum LTO_tags tag == C + 1
185 2- Given a gimple code C:
186 enum LTO_tags tag == C + NUM_TREE_CODES + 1
188 Conversely, to map between LTO tags and tree/gimple codes, the
189 reverse operation must be applied. */
190 LTO_bb0 = 1 + NUM_TREE_CODES + LAST_AND_UNUSED_GIMPLE_CODE,
193 /* EH region holding the previous statement. */
196 /* An MD or NORMAL builtin. Only the code and class are streamed out. */
205 /* EH region types. These mirror enum eh_region_type. */
208 LTO_ert_allowed_exceptions,
209 LTO_ert_must_not_throw,
211 /* EH landing pad. */
214 /* EH try/catch node. */
217 /* Special for global streamer. Reference to previously-streamed node. */
218 LTO_tree_pickle_reference,
220 /* References to indexable tree nodes. These objects are stored in
221 tables that are written separately from the function bodies that
222 reference them. This way they can be instantiated even when the
223 referencing functions aren't (e.g., during WPA) and it also allows
224 functions to be copied from one file to another without having
225 to unpickle the body first (the references are location
228 NOTE, do not regroup these values as the grouping is exposed
229 in the range checks done in lto_input_tree. */
230 LTO_field_decl_ref, /* Do not change. */
231 LTO_function_decl_ref,
233 LTO_namespace_decl_ref,
239 LTO_imported_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_N_SECTION_TYPES /* Must be last. */
269 /* Indices to the various function, type and symbol streams. */
272 LTO_DECL_STREAM_TYPE = 0, /* Must be first. */
273 LTO_DECL_STREAM_FIELD_DECL,
274 LTO_DECL_STREAM_FN_DECL,
275 LTO_DECL_STREAM_VAR_DECL,
276 LTO_DECL_STREAM_TYPE_DECL,
277 LTO_DECL_STREAM_NAMESPACE_DECL,
278 LTO_DECL_STREAM_LABEL_DECL,
280 } lto_decl_stream_e_t;
282 typedef enum ld_plugin_symbol_resolution ld_plugin_symbol_resolution_t;
283 DEF_VEC_I(ld_plugin_symbol_resolution_t);
284 DEF_VEC_ALLOC_I(ld_plugin_symbol_resolution_t, heap);
287 /* Macro to define convenience functions for type and decl streams
288 in lto_file_decl_data. */
289 #define DEFINE_DECL_STREAM_FUNCS(UPPER_NAME, name) \
291 lto_file_decl_data_get_ ## name (struct lto_file_decl_data *data, \
294 struct lto_in_decl_state *state = data->current_decl_state; \
295 gcc_assert (idx < state->streams[LTO_DECL_STREAM_## UPPER_NAME].size); \
296 return state->streams[LTO_DECL_STREAM_## UPPER_NAME].trees[idx]; \
299 static inline unsigned int \
300 lto_file_decl_data_num_ ## name ## s (struct lto_file_decl_data *data) \
302 struct lto_in_decl_state *state = data->current_decl_state; \
303 return state->streams[LTO_DECL_STREAM_## UPPER_NAME].size; \
307 /* Return a char pointer to the start of a data stream for an lto pass
308 or function. The first parameter is the file data that contains
309 the information. The second parameter is the type of information
310 to be obtained. The third parameter is the name of the function
311 and is only used when finding a function body; otherwise it is
312 NULL. The fourth parameter is the length of the data returned. */
313 typedef const char* (lto_get_section_data_f) (struct lto_file_decl_data *,
314 enum lto_section_type,
318 /* Return the data found from the above call. The first three
319 parameters are the same as above. The fourth parameter is the data
320 itself and the fifth is the lenght of the data. */
321 typedef void (lto_free_section_data_f) (struct lto_file_decl_data *,
322 enum lto_section_type,
327 /* Cache of pickled nodes. Used to avoid writing the same node more
328 than once. The first time a tree node is streamed out, it is
329 entered in this cache. Subsequent references to the same node are
330 resolved by looking it up in this cache.
332 This is used in two ways:
334 - On the writing side, the first time T is added to STREAMER_CACHE,
335 a new reference index is created for T and T is emitted on the
336 stream. If T needs to be emitted again to the stream, instead of
337 pickling it again, the reference index is emitted.
339 - On the reading side, the first time T is read from the stream, it
340 is reconstructed in memory and a new reference index created for
341 T. The reconstructed T is inserted in some array so that when
342 the reference index for T is found in the input stream, it can be
343 used to look up into the array to get the reconstructed T. */
344 struct lto_streamer_cache_d
346 /* The mapping between tree nodes and slots into the nodes array. */
349 /* Next available slot in the nodes and offsets arrays. */
352 /* The nodes pickled so far. */
355 /* Offset into the stream where the nodes have been written. */
356 VEC(unsigned,heap) *offsets;
360 /* Structure used as buffer for reading an LTO file. */
361 struct lto_input_block
368 #define LTO_INIT_INPUT_BLOCK(BASE,D,P,L) \
375 #define LTO_INIT_INPUT_BLOCK_PTR(BASE,D,P,L) \
383 /* The is the first part of the record for a function or constructor
387 int16_t major_version;
388 int16_t minor_version;
389 enum lto_section_type section_type;
392 /* The header for a function body. */
393 struct lto_function_header
395 /* The header for all types of sections. */
396 struct lto_header lto_header;
398 /* Number of labels with names. */
399 int32_t num_named_labels;
401 /* Number of labels without names. */
402 int32_t num_unnamed_labels;
404 /* Size compressed or 0 if not compressed. */
405 int32_t compressed_size;
407 /* Size of names for named labels. */
408 int32_t named_label_size;
410 /* Size of the cfg. */
413 /* Size of main gimple body of function. */
416 /* Size of the string table. */
421 /* Structure describing a symbol section. */
422 struct lto_decl_header
424 /* The header for all types of sections. */
425 struct lto_header lto_header;
427 /* Size of region for decl state. */
428 int32_t decl_state_size;
430 /* Number of nodes in globals stream. */
433 /* Size of region for expressions, decls, types, etc. */
436 /* Size of the string table. */
441 /* Statistics gathered during LTO, WPA and LTRANS. */
444 unsigned HOST_WIDE_INT num_input_cgraph_nodes;
445 unsigned HOST_WIDE_INT num_output_cgraph_nodes;
446 unsigned HOST_WIDE_INT num_input_files;
447 unsigned HOST_WIDE_INT num_output_files;
448 unsigned HOST_WIDE_INT num_cgraph_partitions;
449 unsigned HOST_WIDE_INT section_size[LTO_N_SECTION_TYPES];
450 unsigned HOST_WIDE_INT num_function_bodies;
451 unsigned HOST_WIDE_INT num_trees[NUM_TREE_CODES];
452 unsigned HOST_WIDE_INT num_output_il_bytes;
453 unsigned HOST_WIDE_INT num_compressed_il_bytes;
454 unsigned HOST_WIDE_INT num_input_il_bytes;
455 unsigned HOST_WIDE_INT num_uncompressed_il_bytes;
458 /* Encoder data structure used to stream callgraph nodes. */
459 struct lto_cgraph_encoder_d
461 /* Map nodes to reference number. */
462 struct pointer_map_t *map;
464 /* Map reference number to node. */
465 VEC(cgraph_node_ptr,heap) *nodes;
468 typedef struct lto_cgraph_encoder_d *lto_cgraph_encoder_t;
470 /* Encoder data structure used to stream callgraph nodes. */
471 struct lto_varpool_encoder_d
473 /* Map nodes to reference number. */
474 struct pointer_map_t *map;
476 /* Map reference number to node. */
477 VEC(varpool_node_ptr,heap) *nodes;
479 /* Map of nodes where we want to output initializer. */
480 struct pointer_set_t *initializer;
482 typedef struct lto_varpool_encoder_d *lto_varpool_encoder_t;
484 /* Mapping from indices to trees. */
485 struct GTY(()) lto_tree_ref_table
487 /* Array of referenced trees . */
488 tree * GTY((length ("%h.size"))) trees;
495 /* Mapping between trees and slots in an array. */
503 /* The lto_tree_ref_encoder struct is used to encode trees into indices. */
505 struct lto_tree_ref_encoder
507 htab_t tree_hash_table; /* Maps pointers to indices. */
508 unsigned int next_index; /* Next available index. */
509 VEC(tree,heap) *trees; /* Maps indices to pointers. */
513 /* Structure to hold states of input scope. */
514 struct GTY(()) lto_in_decl_state
516 /* Array of lto_in_decl_buffers to store type and decls streams. */
517 struct lto_tree_ref_table streams[LTO_N_DECL_STREAMS];
519 /* If this in-decl state is associated with a function. FN_DECL
520 point to the FUNCTION_DECL. */
524 typedef struct lto_in_decl_state *lto_in_decl_state_ptr;
527 /* The structure that holds all of the vectors of global types,
528 decls and cgraph nodes used in the serialization of this file. */
529 struct lto_out_decl_state
531 /* The buffers contain the sets of decls of various kinds and types we have
532 seen so far and the indexes assigned to them. */
533 struct lto_tree_ref_encoder streams[LTO_N_DECL_STREAMS];
535 /* Encoder for cgraph nodes. */
536 lto_cgraph_encoder_t cgraph_node_encoder;
538 /* Encoder for varpool nodes. */
539 lto_varpool_encoder_t varpool_node_encoder;
541 /* If this out-decl state belongs to a function, fn_decl points to that
542 function. Otherwise, it is NULL. */
546 typedef struct lto_out_decl_state *lto_out_decl_state_ptr;
548 DEF_VEC_P(lto_out_decl_state_ptr);
549 DEF_VEC_ALLOC_P(lto_out_decl_state_ptr, heap);
551 /* One of these is allocated for each object file that being compiled
552 by lto. This structure contains the tables that are needed by the
553 serialized functions and ipa passes to connect themselves to the
554 global types and decls as they are reconstituted. */
555 struct GTY(()) lto_file_decl_data
557 /* Decl state currently used. */
558 struct lto_in_decl_state *current_decl_state;
560 /* Decl state corresponding to regions outside of any functions
561 in the compilation unit. */
562 struct lto_in_decl_state *global_decl_state;
564 /* Table of cgraph nodes present in this file. */
565 lto_cgraph_encoder_t GTY((skip)) cgraph_node_encoder;
567 /* Table of varpool nodes present in this file. */
568 lto_varpool_encoder_t GTY((skip)) varpool_node_encoder;
570 /* Hash table maps lto-related section names to location in file. */
571 htab_t GTY((param_is (struct lto_in_decl_state))) function_decl_states;
573 /* The .o file that these offsets relate to. */
574 const char *GTY((skip)) file_name;
576 /* Hash table maps lto-related section names to location in file. */
577 htab_t GTY((skip)) section_hash_table;
579 /* Hash new name of renamed global declaration to its original name. */
580 htab_t GTY((skip)) renaming_hash_table;
583 struct lto_char_ptr_base
588 /* An incore byte stream to buffer the various parts of the function.
589 The entire structure should be zeroed when created. The record
590 consists of a set of blocks. The first sizeof (ptr) bytes are used
591 as a chain, and the rest store the bytes to be written. */
592 struct lto_output_stream
594 /* The pointer to the first block in the stream. */
595 struct lto_char_ptr_base * first_block;
597 /* The pointer to the last and current block in the stream. */
598 struct lto_char_ptr_base * current_block;
600 /* The pointer to where the next char should be written. */
601 char * current_pointer;
603 /* The number of characters left in the current block. */
604 unsigned int left_in_block;
606 /* The block size of the last block allocated. */
607 unsigned int block_size;
609 /* The total number of characters written. */
610 unsigned int total_size;
613 /* The is the first part of the record in an LTO file for many of the
615 struct lto_simple_header
617 /* The header for all types of sections. */
618 struct lto_header lto_header;
620 /* Size of main gimple body of function. */
623 /* Size of main stream when compressed. */
624 int32_t compressed_size;
627 /* A simple output block. This can be used for simple IPA passes that
628 do not need more than one stream. */
629 struct lto_simple_output_block
631 enum lto_section_type section_type;
632 struct lto_out_decl_state *decl_state;
634 /* The stream that the main tree codes are written to. */
635 struct lto_output_stream *main_stream;
638 /* Data structure holding all the data and descriptors used when writing
642 enum lto_section_type section_type;
643 struct lto_out_decl_state *decl_state;
645 /* The stream that the main tree codes are written to. */
646 struct lto_output_stream *main_stream;
648 /* The stream that contains the string table. */
649 struct lto_output_stream *string_stream;
651 /* The stream that contains the cfg. */
652 struct lto_output_stream *cfg_stream;
654 /* The hash table that contains the set of strings we have seen so
655 far and the indexes assigned to them. */
656 htab_t string_hash_table;
658 /* The current cgraph_node that we are currently serializing. Null
659 if we are serializing something else. */
660 struct cgraph_node *cgraph_node;
662 /* These are the last file and line that were seen in the stream.
663 If the current node differs from these, it needs to insert
664 something into the stream and fix these up. */
665 const char *current_file;
669 /* True if writing globals and types. */
672 /* Cache of nodes written in this section. */
673 struct lto_streamer_cache_d *writer_cache;
677 /* Data and descriptors used when reading from an LTO file. */
680 /* The global decls and types. */
681 struct lto_file_decl_data *file_data;
683 /* All of the labels. */
686 /* The string table. */
689 /* The length of the string table. */
690 unsigned int strings_len;
692 /* Number of named labels. Used to find the index of unnamed labels
693 since they share space with the named labels. */
694 unsigned int num_named_labels;
696 /* Number of unnamed labels. */
697 unsigned int num_unnamed_labels;
699 const char *current_file;
703 /* Maps each reference number to the resolution done by the linker. */
704 VEC(ld_plugin_symbol_resolution_t,heap) *globals_resolution;
706 /* Cache of pickled nodes. */
707 struct lto_streamer_cache_d *reader_cache;
711 /* In lto-section-in.c */
712 extern struct lto_input_block * lto_create_simple_input_block (
713 struct lto_file_decl_data *,
714 enum lto_section_type, const char **, size_t *);
716 lto_destroy_simple_input_block (struct lto_file_decl_data *,
717 enum lto_section_type,
718 struct lto_input_block *, const char *, size_t);
719 extern void lto_set_in_hooks (struct lto_file_decl_data **,
720 lto_get_section_data_f *,
721 lto_free_section_data_f *);
722 extern struct lto_file_decl_data **lto_get_file_decl_data (void);
723 extern const char *lto_get_section_data (struct lto_file_decl_data *,
724 enum lto_section_type,
725 const char *, size_t *);
726 extern void lto_free_section_data (struct lto_file_decl_data *,
727 enum lto_section_type,
728 const char *, const char *, size_t);
729 extern unsigned char lto_input_1_unsigned (struct lto_input_block *);
730 extern unsigned HOST_WIDE_INT lto_input_uleb128 (struct lto_input_block *);
731 extern unsigned HOST_WIDEST_INT lto_input_widest_uint_uleb128 (
732 struct lto_input_block *);
733 extern HOST_WIDE_INT lto_input_sleb128 (struct lto_input_block *);
734 extern htab_t lto_create_renaming_table (void);
735 extern void lto_record_renamed_decl (struct lto_file_decl_data *,
736 const char *, const char *);
737 extern const char *lto_get_decl_name_mapping (struct lto_file_decl_data *,
739 extern struct lto_in_decl_state *lto_new_in_decl_state (void);
740 extern void lto_delete_in_decl_state (struct lto_in_decl_state *);
741 extern hashval_t lto_hash_in_decl_state (const void *);
742 extern int lto_eq_in_decl_state (const void *, const void *);
743 extern struct lto_in_decl_state *lto_get_function_in_decl_state (
744 struct lto_file_decl_data *, tree);
746 /* In lto-section-out.c */
747 extern hashval_t lto_hash_decl_slot_node (const void *);
748 extern int lto_eq_decl_slot_node (const void *, const void *);
749 extern hashval_t lto_hash_type_slot_node (const void *);
750 extern int lto_eq_type_slot_node (const void *, const void *);
751 extern void lto_begin_section (const char *, bool);
752 extern void lto_end_section (void);
753 extern void lto_write_stream (struct lto_output_stream *);
754 extern void lto_output_1_stream (struct lto_output_stream *, char);
755 extern void lto_output_data_stream (struct lto_output_stream *, const void *,
757 extern void lto_output_uleb128_stream (struct lto_output_stream *,
758 unsigned HOST_WIDE_INT);
759 extern void lto_output_widest_uint_uleb128_stream (struct lto_output_stream *,
760 unsigned HOST_WIDEST_INT);
761 extern void lto_output_sleb128_stream (struct lto_output_stream *,
763 extern bool lto_output_decl_index (struct lto_output_stream *,
764 struct lto_tree_ref_encoder *,
765 tree, unsigned int *);
766 extern void lto_output_field_decl_index (struct lto_out_decl_state *,
767 struct lto_output_stream *, tree);
768 extern void lto_output_fn_decl_index (struct lto_out_decl_state *,
769 struct lto_output_stream *, tree);
770 extern void lto_output_namespace_decl_index (struct lto_out_decl_state *,
771 struct lto_output_stream *, tree);
772 extern void lto_output_var_decl_index (struct lto_out_decl_state *,
773 struct lto_output_stream *, tree);
774 extern void lto_output_type_decl_index (struct lto_out_decl_state *,
775 struct lto_output_stream *, tree);
776 extern void lto_output_type_ref_index (struct lto_out_decl_state *,
777 struct lto_output_stream *, tree);
778 extern struct lto_simple_output_block *lto_create_simple_output_block (
779 enum lto_section_type);
780 extern void lto_destroy_simple_output_block (struct lto_simple_output_block *);
781 extern struct lto_out_decl_state *lto_new_out_decl_state (void);
782 extern void lto_delete_out_decl_state (struct lto_out_decl_state *);
783 extern struct lto_out_decl_state *lto_get_out_decl_state (void);
784 extern void lto_push_out_decl_state (struct lto_out_decl_state *);
785 extern struct lto_out_decl_state *lto_pop_out_decl_state (void);
786 extern void lto_record_function_out_decl_state (tree,
787 struct lto_out_decl_state *);
790 /* In lto-streamer.c. */
791 extern const char *lto_tag_name (enum LTO_tags);
792 extern bitmap lto_bitmap_alloc (void);
793 extern void lto_bitmap_free (bitmap);
794 extern char *lto_get_section_name (int, const char *);
795 extern void print_lto_report (void);
796 extern struct bitpack_d *bitpack_create (void);
797 extern void bitpack_delete (struct bitpack_d *);
798 extern void bp_pack_value (struct bitpack_d *, bitpack_word_t, unsigned);
799 extern bitpack_word_t bp_unpack_value (struct bitpack_d *, unsigned);
800 extern bool lto_streamer_cache_insert (struct lto_streamer_cache_d *, tree,
802 extern bool lto_streamer_cache_insert_at (struct lto_streamer_cache_d *, tree,
804 extern bool lto_streamer_cache_lookup (struct lto_streamer_cache_d *, tree,
806 extern tree lto_streamer_cache_get (struct lto_streamer_cache_d *, int);
807 extern struct lto_streamer_cache_d *lto_streamer_cache_create (void);
808 extern void lto_streamer_cache_delete (struct lto_streamer_cache_d *);
809 extern void lto_streamer_init (void);
810 extern bool gate_lto_out (void);
811 #ifdef LTO_STREAMER_DEBUG
812 extern void lto_orig_address_map (tree, intptr_t);
813 extern intptr_t lto_orig_address_get (tree);
814 extern void lto_orig_address_remove (tree);
816 extern void lto_check_version (int, int);
819 /* In lto-streamer-in.c */
820 extern void lto_input_cgraph (struct lto_file_decl_data *, const char *);
821 extern void lto_init_reader (void);
822 extern tree lto_input_tree (struct lto_input_block *, struct data_in *);
823 extern void lto_input_function_body (struct lto_file_decl_data *, tree,
825 extern void lto_input_constructors_and_inits (struct lto_file_decl_data *,
827 extern struct bitpack_d *lto_input_bitpack (struct lto_input_block *);
828 extern void lto_init_reader (void);
829 extern struct data_in *lto_data_in_create (struct lto_file_decl_data *,
830 const char *, unsigned,
831 VEC(ld_plugin_symbol_resolution_t,heap) *);
832 extern void lto_data_in_delete (struct data_in *);
835 /* In lto-streamer-out.c */
836 extern void lto_register_decl_definition (tree, struct lto_file_decl_data *);
837 extern struct output_block *create_output_block (enum lto_section_type);
838 extern void destroy_output_block (struct output_block *);
839 extern void lto_output_tree (struct output_block *, tree, bool);
840 extern void lto_output_bitpack (struct lto_output_stream *, struct bitpack_d *);
841 extern void produce_asm (struct output_block *ob, tree fn);
844 /* In lto-cgraph.c */
845 struct cgraph_node *lto_cgraph_encoder_deref (lto_cgraph_encoder_t, int);
846 int lto_cgraph_encoder_lookup (lto_cgraph_encoder_t, struct cgraph_node *);
847 lto_cgraph_encoder_t lto_cgraph_encoder_new (void);
848 int lto_cgraph_encoder_encode (lto_cgraph_encoder_t, struct cgraph_node *);
849 void lto_cgraph_encoder_delete (lto_cgraph_encoder_t);
850 struct varpool_node *lto_varpool_encoder_deref (lto_varpool_encoder_t, int);
851 int lto_varpool_encoder_lookup (lto_varpool_encoder_t, struct varpool_node *);
852 lto_varpool_encoder_t lto_varpool_encoder_new (void);
853 int lto_varpool_encoder_encode (lto_varpool_encoder_t, struct varpool_node *);
854 void lto_varpool_encoder_delete (lto_varpool_encoder_t);
855 bool lto_varpool_encoder_encode_initializer_p (lto_varpool_encoder_t,
856 struct varpool_node *);
857 void output_cgraph (cgraph_node_set, varpool_node_set);
858 void input_cgraph (void);
859 bool referenced_from_other_partition_p (struct ipa_ref_list *,
861 varpool_node_set vset);
864 /* In lto-symtab.c. */
865 extern void lto_symtab_register_decl (tree, ld_plugin_symbol_resolution_t,
866 struct lto_file_decl_data *);
867 extern void lto_symtab_merge_decls (void);
868 extern void lto_symtab_merge_cgraph_nodes (void);
869 extern tree lto_symtab_prevailing_decl (tree decl);
870 extern enum ld_plugin_symbol_resolution lto_symtab_get_resolution (tree decl);
874 extern void lto_register_user_option (size_t, const char *, int, int);
875 extern void lto_read_file_options (struct lto_file_decl_data *);
876 extern void lto_write_options (void);
877 extern void lto_reissue_options (void);
878 void lto_clear_user_options (void);
879 void lto_clear_file_options (void);
882 /* In lto-wpa-fixup.c */
883 void lto_mark_nothrow_fndecl (tree);
884 void lto_fixup_nothrow_decls (void);
887 /* Statistics gathered during LTO, WPA and LTRANS. */
888 extern struct lto_stats_d lto_stats;
890 /* Section names corresponding to the values of enum lto_section_type. */
891 extern const char *lto_section_name[];
893 /* Holds all the out decl states of functions output so far in the
894 current output file. */
895 extern VEC(lto_out_decl_state_ptr, heap) *lto_function_decl_states;
897 /* Return true if LTO tag TAG corresponds to a tree code. */
899 lto_tag_is_tree_code_p (enum LTO_tags tag)
901 return tag > LTO_null && (unsigned) tag <= NUM_TREE_CODES;
905 /* Return true if LTO tag TAG corresponds to a gimple code. */
907 lto_tag_is_gimple_code_p (enum LTO_tags tag)
909 return (unsigned) tag >= NUM_TREE_CODES + 1
910 && (unsigned) tag < 1 + NUM_TREE_CODES + LAST_AND_UNUSED_GIMPLE_CODE;
914 /* Return the LTO tag corresponding to gimple code CODE. See enum
915 LTO_tags for details on the conversion. */
916 static inline enum LTO_tags
917 lto_gimple_code_to_tag (enum gimple_code code)
919 return (enum LTO_tags) ((unsigned) code + NUM_TREE_CODES + 1);
923 /* Return the GIMPLE code corresponding to TAG. See enum LTO_tags for
924 details on the conversion. */
925 static inline enum gimple_code
926 lto_tag_to_gimple_code (enum LTO_tags tag)
928 gcc_assert (lto_tag_is_gimple_code_p (tag));
929 return (enum gimple_code) ((unsigned) tag - NUM_TREE_CODES - 1);
933 /* Return the LTO tag corresponding to tree code CODE. See enum
934 LTO_tags for details on the conversion. */
935 static inline enum LTO_tags
936 lto_tree_code_to_tag (enum tree_code code)
938 return (enum LTO_tags) ((unsigned) code + 1);
942 /* Return the tree code corresponding to TAG. See enum LTO_tags for
943 details on the conversion. */
944 static inline enum tree_code
945 lto_tag_to_tree_code (enum LTO_tags tag)
947 gcc_assert (lto_tag_is_tree_code_p (tag));
948 return (enum tree_code) ((unsigned) tag - 1);
951 /* Initialize an lto_out_decl_buffer ENCODER. */
953 lto_init_tree_ref_encoder (struct lto_tree_ref_encoder *encoder,
954 htab_hash hash_fn, htab_eq eq_fn)
956 encoder->tree_hash_table = htab_create (37, hash_fn, eq_fn, free);
957 encoder->next_index = 0;
958 encoder->trees = NULL;
962 /* Destory an lto_tree_ref_encoder ENCODER by freeing its contents. The
963 memory used by ENCODER is not freed by this function. */
965 lto_destroy_tree_ref_encoder (struct lto_tree_ref_encoder *encoder)
967 /* Hash table may be delete already. */
968 if (encoder->tree_hash_table)
969 htab_delete (encoder->tree_hash_table);
970 VEC_free (tree, heap, encoder->trees);
973 /* Return the number of trees encoded in ENCODER. */
974 static inline unsigned int
975 lto_tree_ref_encoder_size (struct lto_tree_ref_encoder *encoder)
977 return VEC_length (tree, encoder->trees);
980 /* Return the IDX-th tree in ENCODER. */
982 lto_tree_ref_encoder_get_tree (struct lto_tree_ref_encoder *encoder,
985 return VEC_index (tree, encoder->trees, idx);
989 /* Return true if LABEL should be emitted in the global context. */
991 emit_label_in_global_context_p (tree label)
993 return DECL_NONLOCAL (label) || FORCED_LABEL (label);
996 /* Return true if tree node EXPR should be streamed as a builtin. For
997 these nodes, we just emit the class and function code. */
999 lto_stream_as_builtin_p (tree expr)
1001 return (TREE_CODE (expr) == FUNCTION_DECL
1002 && DECL_IS_BUILTIN (expr)
1003 && (DECL_BUILT_IN_CLASS (expr) == BUILT_IN_NORMAL
1004 || DECL_BUILT_IN_CLASS (expr) == BUILT_IN_MD));
1007 /* Return true if EXPR is a tree node that can be written to disk. */
1009 lto_is_streamable (tree expr)
1011 enum tree_code code = TREE_CODE (expr);
1013 /* Notice that we reject SSA_NAMEs as well. We only emit the SSA
1014 name version in lto_output_tree_ref (see output_ssa_names). */
1015 return !is_lang_specific (expr)
1017 && code != CALL_EXPR
1018 && code != LANG_TYPE
1019 && code != MODIFY_EXPR
1020 && code != INIT_EXPR
1021 && code != TARGET_EXPR
1022 && code != BIND_EXPR
1023 && code != WITH_CLEANUP_EXPR
1024 && code != STATEMENT_LIST
1025 && (code == CASE_LABEL_EXPR
1026 || code == DECL_EXPR
1027 || TREE_CODE_CLASS (code) != tcc_statement);
1030 DEFINE_DECL_STREAM_FUNCS (TYPE, type)
1031 DEFINE_DECL_STREAM_FUNCS (FIELD_DECL, field_decl)
1032 DEFINE_DECL_STREAM_FUNCS (FN_DECL, fn_decl)
1033 DEFINE_DECL_STREAM_FUNCS (VAR_DECL, var_decl)
1034 DEFINE_DECL_STREAM_FUNCS (TYPE_DECL, type_decl)
1035 DEFINE_DECL_STREAM_FUNCS (NAMESPACE_DECL, namespace_decl)
1036 DEFINE_DECL_STREAM_FUNCS (LABEL_DECL, label_decl)
1038 #endif /* GCC_LTO_STREAMER_H */