1 /* Data structures and declarations used for reading and writing
2 GIMPLE to a file stream.
4 Copyright (C) 2009-2015 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"
28 #include "alloc-pool.h"
30 #include "diagnostic.h"
32 /* Define when debugging the LTO streamer. This causes the writer
33 to output the numeric value for the memory address of the tree node
34 being emitted. When debugging a problem in the reader, check the
35 original address that the writer was emitting using lto_orig_address_get.
36 With this value, set a breakpoint in the writer (e.g., lto_output_tree)
37 to trace how the faulty node is being emitted. */
38 /* #define LTO_STREAMER_DEBUG 1 */
40 /* The encoding for a function consists of the following sections:
48 7) Names for the labels that have names
50 9) The control flow graph.
51 10-11)Gimple for local decls.
52 12) Gimple for the function.
56 2-6) THE GLOBAL DECLS AND TYPES.
58 The global decls and types are encoded in the same way. For each
59 entry, there is word with the offset within the section to the
64 Since most labels do not have names, this section my be of zero
65 length. It consists of an array of string table references, one
66 per label. In the lto code, the labels are given either
67 positive or negative indexes. the positive ones have names and
68 the negative ones do not. The positive index can be used to
69 find the name in this array.
73 10) Index into the local decls. Since local decls can have local
74 decls inside them, they must be read in randomly in order to
75 properly restore them.
77 11-12) GIMPLE FOR THE LOCAL DECLS AND THE FUNCTION BODY.
79 The gimple consists of a set of records.
83 At the top level of (8) is the function. It consists of five
86 LTO_function - The tag.
87 eh tree - This is all of the exception handling regions
88 put out in a post order traversial of the
89 tree. Siblings are output as lists terminated
90 by a 0. The set of fields matches the fields
93 last_basic_block - in uleb128 form.
95 basic blocks - This is the set of basic blocks.
97 zero - The termination of the basic blocks.
101 There are two forms of basic blocks depending on if they are
104 The basic block consists of:
106 LTO_bb1 or LTO_bb0 - The tag.
108 bb->index - the index in uleb128 form.
110 #succs - The number of successors un uleb128 form.
112 the successors - For each edge, a pair. The first of the
113 pair is the index of the successor in
114 uleb128 form and the second are the flags in
117 the statements - A gimple tree, as described above.
118 These are only present for LTO_BB1.
119 Following each statement is an optional
120 exception handling record LTO_eh_region
121 which contains the region number (for
124 zero - This is only present for LTO_BB1 and is used
125 to terminate the statements and exception
126 regions within this block.
130 String are represented in the table as pairs, a length in ULEB128
131 form followed by the data for the string. */
133 #define LTO_major_version 5
134 #define LTO_minor_version 0
136 typedef unsigned char lto_decl_flags_t
;
139 /* Tags representing the various IL objects written to the bytecode file
140 (GIMPLE statements, basic blocks, EH regions, tree nodes, etc).
142 NOTE, when adding new LTO tags, also update lto_tag_name. */
147 /* Special for streamer. Reference to previously-streamed node. */
148 LTO_tree_pickle_reference
,
150 /* Reserve enough entries to fit all the tree and gimple codes handled
151 by the streamer. This guarantees that:
153 1- Given a tree code C:
154 enum LTO_tags tag == C + 1
156 2- Given a gimple code C:
157 enum LTO_tags tag == C + NUM_TREE_CODES + 1
159 Conversely, to map between LTO tags and tree/gimple codes, the
160 reverse operation must be applied. */
161 LTO_bb0
= 1 + MAX_TREE_CODES
+ LAST_AND_UNUSED_GIMPLE_CODE
,
164 /* EH region holding the previous statement. */
167 /* An MD or NORMAL builtin. Only the code and class are streamed out. */
170 /* Shared INTEGER_CST node. */
179 /* EH region types. These mirror enum eh_region_type. */
182 LTO_ert_allowed_exceptions
,
183 LTO_ert_must_not_throw
,
185 /* EH landing pad. */
188 /* EH try/catch node. */
191 /* Special for global streamer. A blob of unnamed tree nodes. */
194 /* References to indexable tree nodes. These objects are stored in
195 tables that are written separately from the function bodies that
196 reference them. This way they can be instantiated even when the
197 referencing functions aren't (e.g., during WPA) and it also allows
198 functions to be copied from one file to another without having
199 to unpickle the body first (the references are location
202 NOTE, do not regroup these values as the grouping is exposed
203 in the range checks done in lto_input_tree. */
204 LTO_field_decl_ref
, /* Do not change. */
205 LTO_function_decl_ref
,
207 LTO_namespace_decl_ref
,
213 LTO_imported_decl_ref
,
214 LTO_translation_unit_decl_ref
,
216 LTO_namelist_decl_ref
, /* Do not change. */
218 /* This tag must always be last. */
223 /* Set of section types that are in an LTO file. This list will grow
224 as the number of IPA passes grows since each IPA pass will need its
225 own section type to store its summary information.
227 When adding a new section type, you must also extend the
228 LTO_SECTION_NAME array in lto-section-in.c. */
229 enum lto_section_type
231 LTO_section_decls
= 0,
232 LTO_section_function_body
,
233 LTO_section_static_initializer
,
237 LTO_section_jump_functions
,
238 LTO_section_ipa_pure_const
,
239 LTO_section_ipa_reference
,
240 LTO_section_ipa_profile
,
241 LTO_section_symtab_nodes
,
243 LTO_section_cgraph_opt_sum
,
244 LTO_section_inline_summary
,
245 LTO_section_ipcp_transform
,
247 LTO_section_offload_table
,
248 LTO_section_mode_table
,
249 LTO_N_SECTION_TYPES
/* Must be last. */
252 /* Indices to the various function, type and symbol streams. */
253 enum lto_decl_stream_e_t
255 LTO_DECL_STREAM_TYPE
= 0, /* Must be first. */
256 LTO_DECL_STREAM_FIELD_DECL
,
257 LTO_DECL_STREAM_FN_DECL
,
258 LTO_DECL_STREAM_VAR_DECL
,
259 LTO_DECL_STREAM_TYPE_DECL
,
260 LTO_DECL_STREAM_NAMESPACE_DECL
,
261 LTO_DECL_STREAM_LABEL_DECL
,
265 typedef enum ld_plugin_symbol_resolution ld_plugin_symbol_resolution_t
;
268 /* Macro to define convenience functions for type and decl streams
269 in lto_file_decl_data. */
270 #define DEFINE_DECL_STREAM_FUNCS(UPPER_NAME, name) \
272 lto_file_decl_data_get_ ## name (struct lto_file_decl_data *data, \
275 struct lto_in_decl_state *state = data->current_decl_state; \
276 return (*state->streams[LTO_DECL_STREAM_## UPPER_NAME])[idx]; \
279 static inline unsigned int \
280 lto_file_decl_data_num_ ## name ## s (struct lto_file_decl_data *data) \
282 struct lto_in_decl_state *state = data->current_decl_state; \
283 return vec_safe_length (state->streams[LTO_DECL_STREAM_## UPPER_NAME]); \
287 /* Return a char pointer to the start of a data stream for an lto pass
288 or function. The first parameter is the file data that contains
289 the information. The second parameter is the type of information
290 to be obtained. The third parameter is the name of the function
291 and is only used when finding a function body; otherwise it is
292 NULL. The fourth parameter is the length of the data returned. */
293 typedef const char* (lto_get_section_data_f
) (struct lto_file_decl_data
*,
294 enum lto_section_type
,
298 /* Return the data found from the above call. The first three
299 parameters are the same as above. The fourth parameter is the data
300 itself and the fifth is the length of the data. */
301 typedef void (lto_free_section_data_f
) (struct lto_file_decl_data
*,
302 enum lto_section_type
,
307 /* The location cache holds expanded locations for streamed in trees.
308 This is done to reduce memory usage of libcpp linemap that strongly preffers
309 locations to be inserted in the soruce order. */
311 class lto_location_cache
314 /* Apply all changes in location cache. Add locations into linemap and patch
316 bool apply_location_cache ();
317 /* Tree merging did not suceed; mark all changes in the cache as accepted. */
318 void accept_location_cache ();
319 /* Tree merging did suceed; throw away recent changes. */
320 void revert_location_cache ();
321 void input_location (location_t
*loc
, struct bitpack_d
*bp
,
322 struct data_in
*data_in
);
323 lto_location_cache ()
324 : loc_cache (), accepted_length (0), current_file (NULL
), current_line (0),
325 current_col (0), current_loc (UNKNOWN_LOCATION
)
327 gcc_assert (!current_cache
);
328 current_cache
= this;
330 ~lto_location_cache ()
332 apply_location_cache ();
333 gcc_assert (current_cache
== this);
334 current_cache
= NULL
;
337 /* There can be at most one instance of location cache (combining multiple
338 would bring it out of sync with libcpp linemap); point to current
340 static lto_location_cache
*current_cache
;
343 static int cmp_loc (const void *pa
, const void *pb
);
345 struct cached_location
352 /* The location cache. */
354 auto_vec
<cached_location
> loc_cache
;
356 /* Accepted entries are ones used by trees that are known to be not unified
361 /* Bookkeeping to remember state in between calls to lto_apply_location_cache
362 When streaming gimple, the location cache is not used and thus
363 lto_apply_location_cache happens per location basis. It is then
364 useful to avoid redundant calls of linemap API. */
366 const char *current_file
;
369 location_t current_loc
;
372 /* Structure used as buffer for reading an LTO file. */
373 class lto_input_block
376 /* Special constructor for the string table, it abuses this to
377 do random access but use the uhwi decoder. */
378 lto_input_block (const char *data_
, unsigned int p_
, unsigned int len_
,
379 const unsigned char *mode_table_
)
380 : data (data_
), mode_table (mode_table_
), p (p_
), len (len_
) {}
381 lto_input_block (const char *data_
, unsigned int len_
,
382 const unsigned char *mode_table_
)
383 : data (data_
), mode_table (mode_table_
), p (0), len (len_
) {}
386 const unsigned char *mode_table
;
392 /* The is the first part of the record for a function or constructor
396 int16_t major_version
;
397 int16_t minor_version
;
400 /* The is the first part of the record in an LTO file for many of the
402 struct lto_simple_header
: lto_header
404 /* Size of main gimple body of function. */
408 struct lto_simple_header_with_strings
: lto_simple_header
410 /* Size of main gimple body of function. */
413 /* Size of the string table. */
417 /* The header for a function body. */
418 struct lto_function_header
: lto_simple_header_with_strings
420 /* Size of the cfg. */
425 /* Structure describing a symbol section. */
426 struct lto_decl_header
: lto_simple_header_with_strings
428 /* Size of region for decl state. */
429 int32_t decl_state_size
;
431 /* Number of nodes in globals stream. */
436 /* Statistics gathered during LTO, WPA and LTRANS. */
439 unsigned HOST_WIDE_INT num_input_cgraph_nodes
;
440 unsigned HOST_WIDE_INT num_output_symtab_nodes
;
441 unsigned HOST_WIDE_INT num_input_files
;
442 unsigned HOST_WIDE_INT num_output_files
;
443 unsigned HOST_WIDE_INT num_cgraph_partitions
;
444 unsigned HOST_WIDE_INT section_size
[LTO_N_SECTION_TYPES
];
445 unsigned HOST_WIDE_INT num_function_bodies
;
446 unsigned HOST_WIDE_INT num_trees
[NUM_TREE_CODES
];
447 unsigned HOST_WIDE_INT num_output_il_bytes
;
448 unsigned HOST_WIDE_INT num_compressed_il_bytes
;
449 unsigned HOST_WIDE_INT num_input_il_bytes
;
450 unsigned HOST_WIDE_INT num_uncompressed_il_bytes
;
451 unsigned HOST_WIDE_INT num_tree_bodies_output
;
452 unsigned HOST_WIDE_INT num_pickle_refs_output
;
455 /* Entry of LTO symtab encoder. */
456 struct lto_encoder_entry
459 /* Is the node in this partition (i.e. ltrans of this partition will
460 be responsible for outputting it)? */
461 unsigned int in_partition
:1;
462 /* Do we encode body in this partition? */
464 /* Do we encode initializer in this partition?
465 For example the readonly variable initializers are encoded to aid
466 constant folding even if they are not in the partition. */
467 unsigned int initializer
:1;
471 /* Encoder data structure used to stream callgraph nodes. */
472 struct lto_symtab_encoder_d
474 vec
<lto_encoder_entry
> nodes
;
475 hash_map
<symtab_node
*, size_t> *map
;
478 typedef struct lto_symtab_encoder_d
*lto_symtab_encoder_t
;
480 /* Iterator structure for cgraph node sets. */
481 struct lto_symtab_encoder_iterator
483 lto_symtab_encoder_t encoder
;
489 /* The lto_tree_ref_encoder struct is used to encode trees into indices. */
491 struct lto_tree_ref_encoder
493 hash_map
<tree
, unsigned> *tree_hash_table
; /* Maps pointers to indices. */
494 vec
<tree
> trees
; /* Maps indices to pointers. */
498 /* Structure to hold states of input scope. */
499 struct GTY((for_user
)) lto_in_decl_state
501 /* Array of lto_in_decl_buffers to store type and decls streams. */
502 vec
<tree
, va_gc
> *streams
[LTO_N_DECL_STREAMS
];
504 /* If this in-decl state is associated with a function. FN_DECL
505 point to the FUNCTION_DECL. */
509 typedef struct lto_in_decl_state
*lto_in_decl_state_ptr
;
511 struct decl_state_hasher
: ggc_ptr_hash
<lto_in_decl_state
>
514 hash (lto_in_decl_state
*s
)
516 return htab_hash_pointer (s
->fn_decl
);
520 equal (lto_in_decl_state
*a
, lto_in_decl_state
*b
)
522 return a
->fn_decl
== b
->fn_decl
;
526 /* The structure that holds all of the vectors of global types,
527 decls and cgraph nodes used in the serialization of this file. */
528 struct lto_out_decl_state
530 /* The buffers contain the sets of decls of various kinds and types we have
531 seen so far and the indexes assigned to them. */
532 struct lto_tree_ref_encoder streams
[LTO_N_DECL_STREAMS
];
534 /* Encoder for cgraph nodes. */
535 lto_symtab_encoder_t symtab_node_encoder
;
537 /* If this out-decl state belongs to a function, fn_decl points to that
538 function. Otherwise, it is NULL. */
542 typedef struct lto_out_decl_state
*lto_out_decl_state_ptr
;
545 /* Compact representation of a index <-> resolution pair. Unpacked to an
549 ld_plugin_symbol_resolution_t res
;
554 /* One of these is allocated for each object file that being compiled
555 by lto. This structure contains the tables that are needed by the
556 serialized functions and ipa passes to connect themselves to the
557 global types and decls as they are reconstituted. */
558 struct GTY(()) lto_file_decl_data
560 /* Decl state currently used. */
561 struct lto_in_decl_state
*current_decl_state
;
563 /* Decl state corresponding to regions outside of any functions
564 in the compilation unit. */
565 struct lto_in_decl_state
*global_decl_state
;
567 /* Table of cgraph nodes present in this file. */
568 lto_symtab_encoder_t
GTY((skip
)) symtab_node_encoder
;
570 /* Hash table maps lto-related section names to location in file. */
571 hash_table
<decl_state_hasher
> *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
;
582 /* Linked list used temporarily in reader */
583 struct lto_file_decl_data
*next
;
585 /* Sub ID for merged objects. */
586 unsigned HOST_WIDE_INT id
;
588 /* Symbol resolutions for this file */
589 vec
<res_pair
> GTY((skip
)) respairs
;
592 struct gcov_ctr_summary
GTY((skip
)) profile_info
;
594 /* Map assigning declarations their resolutions. */
595 hash_map
<tree
, ld_plugin_symbol_resolution
> * GTY((skip
)) resolution_map
;
597 /* Mode translation table. */
598 const unsigned char *mode_table
;
601 typedef struct lto_file_decl_data
*lto_file_decl_data_ptr
;
603 struct lto_char_ptr_base
608 /* An incore byte stream to buffer the various parts of the function.
609 The entire structure should be zeroed when created. The record
610 consists of a set of blocks. The first sizeof (ptr) bytes are used
611 as a chain, and the rest store the bytes to be written. */
612 struct lto_output_stream
614 /* The pointer to the first block in the stream. */
615 struct lto_char_ptr_base
* first_block
;
617 /* The pointer to the last and current block in the stream. */
618 struct lto_char_ptr_base
* current_block
;
620 /* The pointer to where the next char should be written. */
621 char * current_pointer
;
623 /* The number of characters left in the current block. */
624 unsigned int left_in_block
;
626 /* The block size of the last block allocated. */
627 unsigned int block_size
;
629 /* The total number of characters written. */
630 unsigned int total_size
;
633 /* A simple output block. This can be used for simple IPA passes that
634 do not need more than one stream. */
635 struct lto_simple_output_block
637 enum lto_section_type section_type
;
638 struct lto_out_decl_state
*decl_state
;
640 /* The stream that the main tree codes are written to. */
641 struct lto_output_stream
*main_stream
;
644 /* String hashing. */
650 unsigned int slot_num
;
653 /* Hashtable helpers. */
655 struct string_slot_hasher
: nofree_ptr_hash
<string_slot
>
657 static inline hashval_t
hash (const string_slot
*);
658 static inline bool equal (const string_slot
*, const string_slot
*);
661 /* Returns a hash code for DS. Adapted from libiberty's htab_hash_string
662 to support strings that may not end in '\0'. */
665 string_slot_hasher::hash (const string_slot
*ds
)
667 hashval_t r
= ds
->len
;
670 for (i
= 0; i
< ds
->len
; i
++)
671 r
= r
* 67 + (unsigned)ds
->s
[i
] - 113;
675 /* Returns nonzero if DS1 and DS2 are equal. */
678 string_slot_hasher::equal (const string_slot
*ds1
, const string_slot
*ds2
)
680 if (ds1
->len
== ds2
->len
)
681 return memcmp (ds1
->s
, ds2
->s
, ds1
->len
) == 0;
686 /* Data structure holding all the data and descriptors used when writing
690 enum lto_section_type section_type
;
691 struct lto_out_decl_state
*decl_state
;
693 /* The stream that the main tree codes are written to. */
694 struct lto_output_stream
*main_stream
;
696 /* The stream that contains the string table. */
697 struct lto_output_stream
*string_stream
;
699 /* The stream that contains the cfg. */
700 struct lto_output_stream
*cfg_stream
;
702 /* The hash table that contains the set of strings we have seen so
703 far and the indexes assigned to them. */
704 hash_table
<string_slot_hasher
> *string_hash_table
;
706 /* The current symbol that we are currently serializing. Null
707 if we are serializing something else. */
710 /* These are the last file and line that were seen in the stream.
711 If the current node differs from these, it needs to insert
712 something into the stream and fix these up. */
713 const char *current_file
;
717 /* Cache of nodes written in this section. */
718 struct streamer_tree_cache_d
*writer_cache
;
720 /* All data persistent across whole duration of output block
722 struct obstack obstack
;
726 /* Data and descriptors used when reading from an LTO file. */
729 /* The global decls and types. */
730 struct lto_file_decl_data
*file_data
;
732 /* The string table. */
735 /* The length of the string table. */
736 unsigned int strings_len
;
738 /* Maps each reference number to the resolution done by the linker. */
739 vec
<ld_plugin_symbol_resolution_t
> globals_resolution
;
741 /* Cache of pickled nodes. */
742 struct streamer_tree_cache_d
*reader_cache
;
744 /* Cache of source code location. */
745 lto_location_cache location_cache
;
749 /* In lto-section-in.c */
750 extern struct lto_input_block
* lto_create_simple_input_block (
751 struct lto_file_decl_data
*,
752 enum lto_section_type
, const char **, size_t *);
754 lto_destroy_simple_input_block (struct lto_file_decl_data
*,
755 enum lto_section_type
,
756 struct lto_input_block
*, const char *, size_t);
757 extern void lto_set_in_hooks (struct lto_file_decl_data
**,
758 lto_get_section_data_f
*,
759 lto_free_section_data_f
*);
760 extern struct lto_file_decl_data
**lto_get_file_decl_data (void);
761 extern const char *lto_get_section_data (struct lto_file_decl_data
*,
762 enum lto_section_type
,
763 const char *, size_t *);
764 extern void lto_free_section_data (struct lto_file_decl_data
*,
765 enum lto_section_type
,
766 const char *, const char *, size_t);
767 extern htab_t
lto_create_renaming_table (void);
768 extern void lto_record_renamed_decl (struct lto_file_decl_data
*,
769 const char *, const char *);
770 extern const char *lto_get_decl_name_mapping (struct lto_file_decl_data
*,
772 extern struct lto_in_decl_state
*lto_new_in_decl_state (void);
773 extern void lto_delete_in_decl_state (struct lto_in_decl_state
*);
774 extern struct lto_in_decl_state
*lto_get_function_in_decl_state (
775 struct lto_file_decl_data
*, tree
);
776 extern void lto_free_function_in_decl_state (struct lto_in_decl_state
*);
777 extern void lto_free_function_in_decl_state_for_node (symtab_node
*);
778 extern void lto_section_overrun (struct lto_input_block
*) ATTRIBUTE_NORETURN
;
779 extern void lto_value_range_error (const char *,
780 HOST_WIDE_INT
, HOST_WIDE_INT
,
781 HOST_WIDE_INT
) ATTRIBUTE_NORETURN
;
783 /* In lto-section-out.c */
784 extern void lto_begin_section (const char *, bool);
785 extern void lto_end_section (void);
786 extern void lto_write_data (const void *, unsigned int);
787 extern void lto_write_stream (struct lto_output_stream
*);
788 extern bool lto_output_decl_index (struct lto_output_stream
*,
789 struct lto_tree_ref_encoder
*,
790 tree
, unsigned int *);
791 extern void lto_output_field_decl_index (struct lto_out_decl_state
*,
792 struct lto_output_stream
*, tree
);
793 extern void lto_output_fn_decl_index (struct lto_out_decl_state
*,
794 struct lto_output_stream
*, tree
);
795 extern void lto_output_namespace_decl_index (struct lto_out_decl_state
*,
796 struct lto_output_stream
*, tree
);
797 extern void lto_output_var_decl_index (struct lto_out_decl_state
*,
798 struct lto_output_stream
*, tree
);
799 extern void lto_output_type_decl_index (struct lto_out_decl_state
*,
800 struct lto_output_stream
*, tree
);
801 extern void lto_output_type_ref_index (struct lto_out_decl_state
*,
802 struct lto_output_stream
*, tree
);
803 extern struct lto_simple_output_block
*lto_create_simple_output_block (
804 enum lto_section_type
);
805 extern void lto_destroy_simple_output_block (struct lto_simple_output_block
*);
806 extern struct lto_out_decl_state
*lto_new_out_decl_state (void);
807 extern void lto_delete_out_decl_state (struct lto_out_decl_state
*);
808 extern struct lto_out_decl_state
*lto_get_out_decl_state (void);
809 extern void lto_push_out_decl_state (struct lto_out_decl_state
*);
810 extern struct lto_out_decl_state
*lto_pop_out_decl_state (void);
811 extern void lto_record_function_out_decl_state (tree
,
812 struct lto_out_decl_state
*);
813 extern void lto_append_block (struct lto_output_stream
*);
816 /* In lto-streamer.c. */
818 /* Set when streaming LTO for offloading compiler. */
819 extern bool lto_stream_offload_p
;
821 extern const char *lto_tag_name (enum LTO_tags
);
822 extern bitmap
lto_bitmap_alloc (void);
823 extern void lto_bitmap_free (bitmap
);
824 extern char *lto_get_section_name (int, const char *, struct lto_file_decl_data
*);
825 extern void print_lto_report (const char *);
826 extern void lto_streamer_init (void);
827 extern bool gate_lto_out (void);
828 #ifdef LTO_STREAMER_DEBUG
829 extern void lto_orig_address_map (tree
, intptr_t);
830 extern intptr_t lto_orig_address_get (tree
);
831 extern void lto_orig_address_remove (tree
);
833 extern void lto_check_version (int, int);
834 extern void lto_streamer_hooks_init (void);
836 /* In lto-streamer-in.c */
837 extern void lto_input_cgraph (struct lto_file_decl_data
*, const char *);
838 extern void lto_reader_init (void);
839 extern void lto_input_function_body (struct lto_file_decl_data
*,
840 struct cgraph_node
*,
842 extern void lto_input_variable_constructor (struct lto_file_decl_data
*,
843 struct varpool_node
*,
845 extern void lto_input_constructors_and_inits (struct lto_file_decl_data
*,
847 extern void lto_input_toplevel_asms (struct lto_file_decl_data
*, int);
848 extern void lto_input_mode_table (struct lto_file_decl_data
*);
849 extern struct data_in
*lto_data_in_create (struct lto_file_decl_data
*,
850 const char *, unsigned,
851 vec
<ld_plugin_symbol_resolution_t
> );
852 extern void lto_data_in_delete (struct data_in
*);
853 extern void lto_input_data_block (struct lto_input_block
*, void *, size_t);
854 void lto_input_location (location_t
*, struct bitpack_d
*, struct data_in
*);
855 location_t
stream_input_location_now (struct bitpack_d
*bp
,
856 struct data_in
*data
);
857 tree
lto_input_tree_ref (struct lto_input_block
*, struct data_in
*,
858 struct function
*, enum LTO_tags
);
859 void lto_tag_check_set (enum LTO_tags
, int, ...);
860 void lto_init_eh (void);
861 hashval_t
lto_input_scc (struct lto_input_block
*, struct data_in
*,
862 unsigned *, unsigned *);
863 tree
lto_input_tree_1 (struct lto_input_block
*, struct data_in
*,
864 enum LTO_tags
, hashval_t hash
);
865 tree
lto_input_tree (struct lto_input_block
*, struct data_in
*);
868 /* In lto-streamer-out.c */
869 extern void lto_register_decl_definition (tree
, struct lto_file_decl_data
*);
870 extern struct output_block
*create_output_block (enum lto_section_type
);
871 extern void destroy_output_block (struct output_block
*);
872 extern void lto_output_tree (struct output_block
*, tree
, bool, bool);
873 extern void lto_output_toplevel_asms (void);
874 extern void produce_asm (struct output_block
*ob
, tree fn
);
875 extern void lto_output ();
876 extern void produce_asm_for_decls ();
877 void lto_output_decl_state_streams (struct output_block
*,
878 struct lto_out_decl_state
*);
879 void lto_output_decl_state_refs (struct output_block
*,
880 struct lto_output_stream
*,
881 struct lto_out_decl_state
*);
882 void lto_output_location (struct output_block
*, struct bitpack_d
*, location_t
);
883 void lto_output_init_mode_table (void);
886 /* In lto-cgraph.c */
887 extern bool asm_nodes_output
;
888 lto_symtab_encoder_t
lto_symtab_encoder_new (bool);
889 int lto_symtab_encoder_encode (lto_symtab_encoder_t
, symtab_node
*);
890 void lto_symtab_encoder_delete (lto_symtab_encoder_t
);
891 bool lto_symtab_encoder_delete_node (lto_symtab_encoder_t
, symtab_node
*);
892 bool lto_symtab_encoder_encode_body_p (lto_symtab_encoder_t
,
893 struct cgraph_node
*);
894 bool lto_symtab_encoder_in_partition_p (lto_symtab_encoder_t
,
896 void lto_set_symtab_encoder_in_partition (lto_symtab_encoder_t
,
899 bool lto_symtab_encoder_encode_initializer_p (lto_symtab_encoder_t
,
901 void output_symtab (void);
902 void input_symtab (void);
903 void output_offload_tables (void);
904 void input_offload_tables (void);
905 bool referenced_from_other_partition_p (struct ipa_ref_list
*,
906 lto_symtab_encoder_t
);
907 bool reachable_from_other_partition_p (struct cgraph_node
*,
908 lto_symtab_encoder_t
);
909 bool referenced_from_this_partition_p (symtab_node
*,
910 lto_symtab_encoder_t
);
911 bool reachable_from_this_partition_p (struct cgraph_node
*,
912 lto_symtab_encoder_t
);
913 lto_symtab_encoder_t
compute_ltrans_boundary (lto_symtab_encoder_t encoder
);
914 void select_what_to_stream (void);
916 /* In options-save.c. */
917 void cl_target_option_stream_out (struct output_block
*, struct bitpack_d
*,
918 struct cl_target_option
*);
920 void cl_target_option_stream_in (struct data_in
*,
922 struct cl_target_option
*);
924 void cl_optimization_stream_out (struct bitpack_d
*, struct cl_optimization
*);
926 void cl_optimization_stream_in (struct bitpack_d
*, struct cl_optimization
*);
929 /* In lto-symtab.c. */
930 extern void lto_symtab_merge_decls (void);
931 extern void lto_symtab_merge_symbols (void);
932 extern tree
lto_symtab_prevailing_decl (tree decl
);
936 extern void lto_write_options (void);
939 /* Statistics gathered during LTO, WPA and LTRANS. */
940 extern struct lto_stats_d lto_stats
;
942 /* Section names corresponding to the values of enum lto_section_type. */
943 extern const char *lto_section_name
[];
945 /* Holds all the out decl states of functions output so far in the
946 current output file. */
947 extern vec
<lto_out_decl_state_ptr
> lto_function_decl_states
;
949 /* Return true if LTO tag TAG corresponds to a tree code. */
951 lto_tag_is_tree_code_p (enum LTO_tags tag
)
953 return tag
> LTO_tree_pickle_reference
&& (unsigned) tag
<= MAX_TREE_CODES
;
957 /* Return true if LTO tag TAG corresponds to a gimple code. */
959 lto_tag_is_gimple_code_p (enum LTO_tags tag
)
961 return (unsigned) tag
>= NUM_TREE_CODES
+ 2
962 && (unsigned) tag
< 2 + NUM_TREE_CODES
+ LAST_AND_UNUSED_GIMPLE_CODE
;
966 /* Return the LTO tag corresponding to gimple code CODE. See enum
967 LTO_tags for details on the conversion. */
968 static inline enum LTO_tags
969 lto_gimple_code_to_tag (enum gimple_code code
)
971 return (enum LTO_tags
) ((unsigned) code
+ NUM_TREE_CODES
+ 2);
975 /* Return the GIMPLE code corresponding to TAG. See enum LTO_tags for
976 details on the conversion. */
977 static inline enum gimple_code
978 lto_tag_to_gimple_code (enum LTO_tags tag
)
980 gcc_assert (lto_tag_is_gimple_code_p (tag
));
981 return (enum gimple_code
) ((unsigned) tag
- NUM_TREE_CODES
- 2);
985 /* Return the LTO tag corresponding to tree code CODE. See enum
986 LTO_tags for details on the conversion. */
987 static inline enum LTO_tags
988 lto_tree_code_to_tag (enum tree_code code
)
990 return (enum LTO_tags
) ((unsigned) code
+ 2);
994 /* Return the tree code corresponding to TAG. See enum LTO_tags for
995 details on the conversion. */
996 static inline enum tree_code
997 lto_tag_to_tree_code (enum LTO_tags tag
)
999 gcc_assert (lto_tag_is_tree_code_p (tag
));
1000 return (enum tree_code
) ((unsigned) tag
- 2);
1003 /* Check that tag ACTUAL == EXPECTED. */
1005 lto_tag_check (enum LTO_tags actual
, enum LTO_tags expected
)
1007 if (actual
!= expected
)
1008 internal_error ("bytecode stream: expected tag %s instead of %s",
1009 lto_tag_name (expected
), lto_tag_name (actual
));
1012 /* Check that tag ACTUAL is in the range [TAG1, TAG2]. */
1014 lto_tag_check_range (enum LTO_tags actual
, enum LTO_tags tag1
,
1017 if (actual
< tag1
|| actual
> tag2
)
1018 internal_error ("bytecode stream: tag %s is not in the expected range "
1020 lto_tag_name (actual
),
1021 lto_tag_name (tag1
),
1022 lto_tag_name (tag2
));
1025 /* Initialize an lto_out_decl_buffer ENCODER. */
1027 lto_init_tree_ref_encoder (struct lto_tree_ref_encoder
*encoder
)
1029 encoder
->tree_hash_table
= new hash_map
<tree
, unsigned> (251);
1030 encoder
->trees
.create (0);
1034 /* Destroy an lto_tree_ref_encoder ENCODER by freeing its contents. The
1035 memory used by ENCODER is not freed by this function. */
1037 lto_destroy_tree_ref_encoder (struct lto_tree_ref_encoder
*encoder
)
1039 /* Hash table may be delete already. */
1040 delete encoder
->tree_hash_table
;
1041 encoder
->tree_hash_table
= NULL
;
1042 encoder
->trees
.release ();
1045 /* Return the number of trees encoded in ENCODER. */
1046 static inline unsigned int
1047 lto_tree_ref_encoder_size (struct lto_tree_ref_encoder
*encoder
)
1049 return encoder
->trees
.length ();
1052 /* Return the IDX-th tree in ENCODER. */
1054 lto_tree_ref_encoder_get_tree (struct lto_tree_ref_encoder
*encoder
,
1057 return encoder
->trees
[idx
];
1060 /* Return number of encoded nodes in ENCODER. */
1062 lto_symtab_encoder_size (lto_symtab_encoder_t encoder
)
1064 return encoder
->nodes
.length ();
1067 /* Value used to represent failure of lto_symtab_encoder_lookup. */
1068 #define LCC_NOT_FOUND (-1)
1070 /* Look up NODE in encoder. Return NODE's reference if it has been encoded
1071 or LCC_NOT_FOUND if it is not there. */
1074 lto_symtab_encoder_lookup (lto_symtab_encoder_t encoder
,
1077 size_t *slot
= encoder
->map
->get (node
);
1078 return (slot
&& *slot
? *(slot
) - 1 : LCC_NOT_FOUND
);
1081 /* Return true if iterator LSE points to nothing. */
1083 lsei_end_p (lto_symtab_encoder_iterator lsei
)
1085 return lsei
.index
>= (unsigned)lto_symtab_encoder_size (lsei
.encoder
);
1088 /* Advance iterator LSE. */
1090 lsei_next (lto_symtab_encoder_iterator
*lsei
)
1095 /* Return the node pointed to by LSI. */
1096 static inline symtab_node
*
1097 lsei_node (lto_symtab_encoder_iterator lsei
)
1099 return lsei
.encoder
->nodes
[lsei
.index
].node
;
1102 /* Return the node pointed to by LSI. */
1103 static inline struct cgraph_node
*
1104 lsei_cgraph_node (lto_symtab_encoder_iterator lsei
)
1106 return dyn_cast
<cgraph_node
*> (lsei
.encoder
->nodes
[lsei
.index
].node
);
1109 /* Return the node pointed to by LSI. */
1110 static inline varpool_node
*
1111 lsei_varpool_node (lto_symtab_encoder_iterator lsei
)
1113 return dyn_cast
<varpool_node
*> (lsei
.encoder
->nodes
[lsei
.index
].node
);
1116 /* Return the cgraph node corresponding to REF using ENCODER. */
1118 static inline symtab_node
*
1119 lto_symtab_encoder_deref (lto_symtab_encoder_t encoder
, int ref
)
1121 if (ref
== LCC_NOT_FOUND
)
1124 return encoder
->nodes
[ref
].node
;
1127 /* Return an iterator to the first node in LSI. */
1128 static inline lto_symtab_encoder_iterator
1129 lsei_start (lto_symtab_encoder_t encoder
)
1131 lto_symtab_encoder_iterator lsei
;
1133 lsei
.encoder
= encoder
;
1138 /* Advance iterator LSE. */
1140 lsei_next_in_partition (lto_symtab_encoder_iterator
*lsei
)
1143 while (!lsei_end_p (*lsei
)
1144 && !lto_symtab_encoder_in_partition_p (lsei
->encoder
, lsei_node (*lsei
)))
1148 /* Return an iterator to the first node in LSI. */
1149 static inline lto_symtab_encoder_iterator
1150 lsei_start_in_partition (lto_symtab_encoder_t encoder
)
1152 lto_symtab_encoder_iterator lsei
= lsei_start (encoder
);
1154 if (lsei_end_p (lsei
))
1156 if (!lto_symtab_encoder_in_partition_p (encoder
, lsei_node (lsei
)))
1157 lsei_next_in_partition (&lsei
);
1162 /* Advance iterator LSE. */
1164 lsei_next_function_in_partition (lto_symtab_encoder_iterator
*lsei
)
1167 while (!lsei_end_p (*lsei
)
1168 && (!is_a
<cgraph_node
*> (lsei_node (*lsei
))
1169 || !lto_symtab_encoder_in_partition_p (lsei
->encoder
, lsei_node (*lsei
))))
1173 /* Return an iterator to the first node in LSI. */
1174 static inline lto_symtab_encoder_iterator
1175 lsei_start_function_in_partition (lto_symtab_encoder_t encoder
)
1177 lto_symtab_encoder_iterator lsei
= lsei_start (encoder
);
1179 if (lsei_end_p (lsei
))
1181 if (!is_a
<cgraph_node
*> (lsei_node (lsei
))
1182 || !lto_symtab_encoder_in_partition_p (encoder
, lsei_node (lsei
)))
1183 lsei_next_function_in_partition (&lsei
);
1188 /* Advance iterator LSE. */
1190 lsei_next_variable_in_partition (lto_symtab_encoder_iterator
*lsei
)
1193 while (!lsei_end_p (*lsei
)
1194 && (!is_a
<varpool_node
*> (lsei_node (*lsei
))
1195 || !lto_symtab_encoder_in_partition_p (lsei
->encoder
, lsei_node (*lsei
))))
1199 /* Return an iterator to the first node in LSI. */
1200 static inline lto_symtab_encoder_iterator
1201 lsei_start_variable_in_partition (lto_symtab_encoder_t encoder
)
1203 lto_symtab_encoder_iterator lsei
= lsei_start (encoder
);
1205 if (lsei_end_p (lsei
))
1207 if (!is_a
<varpool_node
*> (lsei_node (lsei
))
1208 || !lto_symtab_encoder_in_partition_p (encoder
, lsei_node (lsei
)))
1209 lsei_next_variable_in_partition (&lsei
);
1214 DEFINE_DECL_STREAM_FUNCS (TYPE
, type
)
1215 DEFINE_DECL_STREAM_FUNCS (FIELD_DECL
, field_decl
)
1216 DEFINE_DECL_STREAM_FUNCS (FN_DECL
, fn_decl
)
1217 DEFINE_DECL_STREAM_FUNCS (VAR_DECL
, var_decl
)
1218 DEFINE_DECL_STREAM_FUNCS (TYPE_DECL
, type_decl
)
1219 DEFINE_DECL_STREAM_FUNCS (NAMESPACE_DECL
, namespace_decl
)
1220 DEFINE_DECL_STREAM_FUNCS (LABEL_DECL
, label_decl
)
1222 #endif /* GCC_LTO_STREAMER_H */