1 /* Data structures and declarations used for reading and writing
2 GIMPLE to a file stream.
4 Copyright (C) 2009-2014 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"
27 #include "hash-table.h"
32 #include "alloc-pool.h"
34 #include "diagnostic.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 #define LTO_major_version 4
138 #define LTO_minor_version 0
140 typedef unsigned char lto_decl_flags_t
;
143 /* Tags representing the various IL objects written to the bytecode file
144 (GIMPLE statements, basic blocks, EH regions, tree nodes, etc).
146 NOTE, when adding new LTO tags, also update lto_tag_name. */
151 /* Special for streamer. Reference to previously-streamed node. */
152 LTO_tree_pickle_reference
,
154 /* Reserve enough entries to fit all the tree and gimple codes handled
155 by the streamer. This guarantees that:
157 1- Given a tree code C:
158 enum LTO_tags tag == C + 1
160 2- Given a gimple code C:
161 enum LTO_tags tag == C + NUM_TREE_CODES + 1
163 Conversely, to map between LTO tags and tree/gimple codes, the
164 reverse operation must be applied. */
165 LTO_bb0
= 1 + MAX_TREE_CODES
+ LAST_AND_UNUSED_GIMPLE_CODE
,
168 /* EH region holding the previous statement. */
171 /* An MD or NORMAL builtin. Only the code and class are streamed out. */
174 /* Shared INTEGER_CST node. */
183 /* EH region types. These mirror enum eh_region_type. */
186 LTO_ert_allowed_exceptions
,
187 LTO_ert_must_not_throw
,
189 /* EH landing pad. */
192 /* EH try/catch node. */
195 /* Special for global streamer. A blob of unnamed tree nodes. */
198 /* References to indexable tree nodes. These objects are stored in
199 tables that are written separately from the function bodies that
200 reference them. This way they can be instantiated even when the
201 referencing functions aren't (e.g., during WPA) and it also allows
202 functions to be copied from one file to another without having
203 to unpickle the body first (the references are location
206 NOTE, do not regroup these values as the grouping is exposed
207 in the range checks done in lto_input_tree. */
208 LTO_field_decl_ref
, /* Do not change. */
209 LTO_function_decl_ref
,
211 LTO_namespace_decl_ref
,
217 LTO_imported_decl_ref
,
218 LTO_translation_unit_decl_ref
,
220 LTO_namelist_decl_ref
, /* Do not change. */
222 /* This tag must always be last. */
227 /* Set of section types that are in an LTO file. This list will grow
228 as the number of IPA passes grows since each IPA pass will need its
229 own section type to store its summary information.
231 When adding a new section type, you must also extend the
232 LTO_SECTION_NAME array in lto-section-in.c. */
233 enum lto_section_type
235 LTO_section_decls
= 0,
236 LTO_section_function_body
,
237 LTO_section_static_initializer
,
241 LTO_section_jump_functions
,
242 LTO_section_ipa_pure_const
,
243 LTO_section_ipa_reference
,
244 LTO_section_ipa_profile
,
245 LTO_section_symtab_nodes
,
247 LTO_section_cgraph_opt_sum
,
248 LTO_section_inline_summary
,
249 LTO_section_ipcp_transform
,
250 LTO_N_SECTION_TYPES
/* Must be last. */
253 /* Indices to the various function, type and symbol streams. */
254 enum lto_decl_stream_e_t
256 LTO_DECL_STREAM_TYPE
= 0, /* Must be first. */
257 LTO_DECL_STREAM_FIELD_DECL
,
258 LTO_DECL_STREAM_FN_DECL
,
259 LTO_DECL_STREAM_VAR_DECL
,
260 LTO_DECL_STREAM_TYPE_DECL
,
261 LTO_DECL_STREAM_NAMESPACE_DECL
,
262 LTO_DECL_STREAM_LABEL_DECL
,
266 typedef enum ld_plugin_symbol_resolution ld_plugin_symbol_resolution_t
;
269 /* Macro to define convenience functions for type and decl streams
270 in lto_file_decl_data. */
271 #define DEFINE_DECL_STREAM_FUNCS(UPPER_NAME, name) \
273 lto_file_decl_data_get_ ## name (struct lto_file_decl_data *data, \
276 struct lto_in_decl_state *state = data->current_decl_state; \
277 gcc_assert (idx < state->streams[LTO_DECL_STREAM_## UPPER_NAME].size); \
278 return state->streams[LTO_DECL_STREAM_## UPPER_NAME].trees[idx]; \
281 static inline unsigned int \
282 lto_file_decl_data_num_ ## name ## s (struct lto_file_decl_data *data) \
284 struct lto_in_decl_state *state = data->current_decl_state; \
285 return state->streams[LTO_DECL_STREAM_## UPPER_NAME].size; \
289 /* Return a char pointer to the start of a data stream for an lto pass
290 or function. The first parameter is the file data that contains
291 the information. The second parameter is the type of information
292 to be obtained. The third parameter is the name of the function
293 and is only used when finding a function body; otherwise it is
294 NULL. The fourth parameter is the length of the data returned. */
295 typedef const char* (lto_get_section_data_f
) (struct lto_file_decl_data
*,
296 enum lto_section_type
,
300 /* Return the data found from the above call. The first three
301 parameters are the same as above. The fourth parameter is the data
302 itself and the fifth is the length of the data. */
303 typedef void (lto_free_section_data_f
) (struct lto_file_decl_data
*,
304 enum lto_section_type
,
309 /* Structure used as buffer for reading an LTO file. */
310 struct lto_input_block
317 #define LTO_INIT_INPUT_BLOCK(BASE,D,P,L) \
324 #define LTO_INIT_INPUT_BLOCK_PTR(BASE,D,P,L) \
332 /* The is the first part of the record for a function or constructor
336 int16_t major_version
;
337 int16_t minor_version
;
340 /* The header for a function body. */
341 struct lto_function_header
343 /* The header for all types of sections. */
344 struct lto_header lto_header
;
346 /* Number of labels with names. */
347 int32_t num_named_labels
;
349 /* Number of labels without names. */
350 int32_t num_unnamed_labels
;
352 /* Size compressed or 0 if not compressed. */
353 int32_t compressed_size
;
355 /* Size of names for named labels. */
356 int32_t named_label_size
;
358 /* Size of the cfg. */
361 /* Size of main gimple body of function. */
364 /* Size of the string table. */
369 /* Structure describing a symbol section. */
370 struct lto_decl_header
372 /* The header for all types of sections. */
373 struct lto_header lto_header
;
375 /* Size of region for decl state. */
376 int32_t decl_state_size
;
378 /* Number of nodes in globals stream. */
381 /* Size of region for expressions, decls, types, etc. */
384 /* Size of the string table. */
389 /* Structure describing top level asm()s. */
390 struct lto_asm_header
392 /* The header for all types of sections. */
393 struct lto_header lto_header
;
395 /* Size compressed or 0 if not compressed. */
396 int32_t compressed_size
;
398 /* Size of region for expressions, decls, types, etc. */
401 /* Size of the string table. */
406 /* Statistics gathered during LTO, WPA and LTRANS. */
409 unsigned HOST_WIDE_INT num_input_cgraph_nodes
;
410 unsigned HOST_WIDE_INT num_output_symtab_nodes
;
411 unsigned HOST_WIDE_INT num_input_files
;
412 unsigned HOST_WIDE_INT num_output_files
;
413 unsigned HOST_WIDE_INT num_cgraph_partitions
;
414 unsigned HOST_WIDE_INT section_size
[LTO_N_SECTION_TYPES
];
415 unsigned HOST_WIDE_INT num_function_bodies
;
416 unsigned HOST_WIDE_INT num_trees
[NUM_TREE_CODES
];
417 unsigned HOST_WIDE_INT num_output_il_bytes
;
418 unsigned HOST_WIDE_INT num_compressed_il_bytes
;
419 unsigned HOST_WIDE_INT num_input_il_bytes
;
420 unsigned HOST_WIDE_INT num_uncompressed_il_bytes
;
421 unsigned HOST_WIDE_INT num_tree_bodies_output
;
422 unsigned HOST_WIDE_INT num_pickle_refs_output
;
425 /* Entry of LTO symtab encoder. */
426 struct lto_encoder_entry
429 /* Is the node in this partition (i.e. ltrans of this partition will
430 be responsible for outputting it)? */
431 unsigned int in_partition
:1;
432 /* Do we encode body in this partition? */
434 /* Do we encode initializer in this partition?
435 For example the readonly variable initializers are encoded to aid
436 constant folding even if they are not in the partition. */
437 unsigned int initializer
:1;
441 /* Encoder data structure used to stream callgraph nodes. */
442 struct lto_symtab_encoder_d
444 vec
<lto_encoder_entry
> nodes
;
445 hash_map
<symtab_node
*, size_t> *map
;
448 typedef struct lto_symtab_encoder_d
*lto_symtab_encoder_t
;
450 /* Iterator structure for cgraph node sets. */
451 struct lto_symtab_encoder_iterator
453 lto_symtab_encoder_t encoder
;
460 /* Mapping from indices to trees. */
461 struct GTY(()) lto_tree_ref_table
463 /* Array of referenced trees . */
464 tree
* GTY((length ("%h.size"))) trees
;
471 /* The lto_tree_ref_encoder struct is used to encode trees into indices. */
473 struct lto_tree_ref_encoder
475 hash_map
<tree
, unsigned> *tree_hash_table
; /* Maps pointers to indices. */
476 vec
<tree
> trees
; /* Maps indices to pointers. */
480 /* Structure to hold states of input scope. */
481 struct GTY(()) lto_in_decl_state
483 /* Array of lto_in_decl_buffers to store type and decls streams. */
484 struct lto_tree_ref_table streams
[LTO_N_DECL_STREAMS
];
486 /* If this in-decl state is associated with a function. FN_DECL
487 point to the FUNCTION_DECL. */
491 typedef struct lto_in_decl_state
*lto_in_decl_state_ptr
;
494 /* The structure that holds all of the vectors of global types,
495 decls and cgraph nodes used in the serialization of this file. */
496 struct lto_out_decl_state
498 /* The buffers contain the sets of decls of various kinds and types we have
499 seen so far and the indexes assigned to them. */
500 struct lto_tree_ref_encoder streams
[LTO_N_DECL_STREAMS
];
502 /* Encoder for cgraph nodes. */
503 lto_symtab_encoder_t symtab_node_encoder
;
505 /* If this out-decl state belongs to a function, fn_decl points to that
506 function. Otherwise, it is NULL. */
510 typedef struct lto_out_decl_state
*lto_out_decl_state_ptr
;
513 /* Compact representation of a index <-> resolution pair. Unpacked to an
517 ld_plugin_symbol_resolution_t res
;
522 /* One of these is allocated for each object file that being compiled
523 by lto. This structure contains the tables that are needed by the
524 serialized functions and ipa passes to connect themselves to the
525 global types and decls as they are reconstituted. */
526 struct GTY(()) lto_file_decl_data
528 /* Decl state currently used. */
529 struct lto_in_decl_state
*current_decl_state
;
531 /* Decl state corresponding to regions outside of any functions
532 in the compilation unit. */
533 struct lto_in_decl_state
*global_decl_state
;
535 /* Table of cgraph nodes present in this file. */
536 lto_symtab_encoder_t
GTY((skip
)) symtab_node_encoder
;
538 /* Hash table maps lto-related section names to location in file. */
539 htab_t
GTY((param_is (struct lto_in_decl_state
))) function_decl_states
;
541 /* The .o file that these offsets relate to. */
542 const char *GTY((skip
)) file_name
;
544 /* Hash table maps lto-related section names to location in file. */
545 htab_t
GTY((skip
)) section_hash_table
;
547 /* Hash new name of renamed global declaration to its original name. */
548 htab_t
GTY((skip
)) renaming_hash_table
;
550 /* Linked list used temporarily in reader */
551 struct lto_file_decl_data
*next
;
553 /* Sub ID for merged objects. */
554 unsigned HOST_WIDE_INT id
;
556 /* Symbol resolutions for this file */
557 vec
<res_pair
> GTY((skip
)) respairs
;
560 struct gcov_ctr_summary
GTY((skip
)) profile_info
;
562 /* Map assigning declarations their resolutions. */
563 hash_map
<tree
, ld_plugin_symbol_resolution
> * GTY((skip
)) resolution_map
;
566 typedef struct lto_file_decl_data
*lto_file_decl_data_ptr
;
568 struct lto_char_ptr_base
573 /* An incore byte stream to buffer the various parts of the function.
574 The entire structure should be zeroed when created. The record
575 consists of a set of blocks. The first sizeof (ptr) bytes are used
576 as a chain, and the rest store the bytes to be written. */
577 struct lto_output_stream
579 /* The pointer to the first block in the stream. */
580 struct lto_char_ptr_base
* first_block
;
582 /* The pointer to the last and current block in the stream. */
583 struct lto_char_ptr_base
* current_block
;
585 /* The pointer to where the next char should be written. */
586 char * current_pointer
;
588 /* The number of characters left in the current block. */
589 unsigned int left_in_block
;
591 /* The block size of the last block allocated. */
592 unsigned int block_size
;
594 /* The total number of characters written. */
595 unsigned int total_size
;
598 /* The is the first part of the record in an LTO file for many of the
600 struct lto_simple_header
602 /* The header for all types of sections. */
603 struct lto_header lto_header
;
605 /* Size of main gimple body of function. */
608 /* Size of main stream when compressed. */
609 int32_t compressed_size
;
612 /* A simple output block. This can be used for simple IPA passes that
613 do not need more than one stream. */
614 struct lto_simple_output_block
616 enum lto_section_type section_type
;
617 struct lto_out_decl_state
*decl_state
;
619 /* The stream that the main tree codes are written to. */
620 struct lto_output_stream
*main_stream
;
623 /* String hashing. */
629 unsigned int slot_num
;
632 /* Hashtable helpers. */
634 struct string_slot_hasher
: typed_noop_remove
<string_slot
>
636 typedef string_slot value_type
;
637 typedef string_slot compare_type
;
638 static inline hashval_t
hash (const value_type
*);
639 static inline bool equal (const value_type
*, const compare_type
*);
642 /* Returns a hash code for DS. Adapted from libiberty's htab_hash_string
643 to support strings that may not end in '\0'. */
646 string_slot_hasher::hash (const value_type
*ds
)
648 hashval_t r
= ds
->len
;
651 for (i
= 0; i
< ds
->len
; i
++)
652 r
= r
* 67 + (unsigned)ds
->s
[i
] - 113;
656 /* Returns nonzero if DS1 and DS2 are equal. */
659 string_slot_hasher::equal (const value_type
*ds1
, const compare_type
*ds2
)
661 if (ds1
->len
== ds2
->len
)
662 return memcmp (ds1
->s
, ds2
->s
, ds1
->len
) == 0;
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 hash_table
<string_slot_hasher
> *string_hash_table
;
687 /* The current symbol that we are currently serializing. Null
688 if we are serializing something else. */
689 struct symtab_node
*symbol
;
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 /* Cache of nodes written in this section. */
699 struct streamer_tree_cache_d
*writer_cache
;
701 /* All data persistent across whole duration of output block
703 struct obstack obstack
;
707 /* Data and descriptors used when reading from an LTO file. */
710 /* The global decls and types. */
711 struct lto_file_decl_data
*file_data
;
713 /* The string table. */
716 /* The length of the string table. */
717 unsigned int strings_len
;
719 /* Maps each reference number to the resolution done by the linker. */
720 vec
<ld_plugin_symbol_resolution_t
> globals_resolution
;
722 /* Cache of pickled nodes. */
723 struct streamer_tree_cache_d
*reader_cache
;
727 /* In lto-section-in.c */
728 extern struct lto_input_block
* lto_create_simple_input_block (
729 struct lto_file_decl_data
*,
730 enum lto_section_type
, const char **, size_t *);
732 lto_destroy_simple_input_block (struct lto_file_decl_data
*,
733 enum lto_section_type
,
734 struct lto_input_block
*, const char *, size_t);
735 extern void lto_set_in_hooks (struct lto_file_decl_data
**,
736 lto_get_section_data_f
*,
737 lto_free_section_data_f
*);
738 extern struct lto_file_decl_data
**lto_get_file_decl_data (void);
739 extern const char *lto_get_section_data (struct lto_file_decl_data
*,
740 enum lto_section_type
,
741 const char *, size_t *);
742 extern void lto_free_section_data (struct lto_file_decl_data
*,
743 enum lto_section_type
,
744 const char *, const char *, size_t);
745 extern htab_t
lto_create_renaming_table (void);
746 extern void lto_record_renamed_decl (struct lto_file_decl_data
*,
747 const char *, const char *);
748 extern const char *lto_get_decl_name_mapping (struct lto_file_decl_data
*,
750 extern struct lto_in_decl_state
*lto_new_in_decl_state (void);
751 extern void lto_delete_in_decl_state (struct lto_in_decl_state
*);
752 extern hashval_t
lto_hash_in_decl_state (const void *);
753 extern int lto_eq_in_decl_state (const void *, const void *);
754 extern struct lto_in_decl_state
*lto_get_function_in_decl_state (
755 struct lto_file_decl_data
*, tree
);
756 extern void lto_free_function_in_decl_state (struct lto_in_decl_state
*);
757 extern void lto_free_function_in_decl_state_for_node (symtab_node
*);
758 extern void lto_section_overrun (struct lto_input_block
*) ATTRIBUTE_NORETURN
;
759 extern void lto_value_range_error (const char *,
760 HOST_WIDE_INT
, HOST_WIDE_INT
,
761 HOST_WIDE_INT
) ATTRIBUTE_NORETURN
;
763 /* In lto-section-out.c */
764 extern void lto_begin_section (const char *, bool);
765 extern void lto_end_section (void);
766 extern void lto_write_data (const void *, unsigned int);
767 extern void lto_write_stream (struct lto_output_stream
*);
768 extern bool lto_output_decl_index (struct lto_output_stream
*,
769 struct lto_tree_ref_encoder
*,
770 tree
, unsigned int *);
771 extern void lto_output_field_decl_index (struct lto_out_decl_state
*,
772 struct lto_output_stream
*, tree
);
773 extern void lto_output_fn_decl_index (struct lto_out_decl_state
*,
774 struct lto_output_stream
*, tree
);
775 extern void lto_output_namespace_decl_index (struct lto_out_decl_state
*,
776 struct lto_output_stream
*, tree
);
777 extern void lto_output_var_decl_index (struct lto_out_decl_state
*,
778 struct lto_output_stream
*, tree
);
779 extern void lto_output_type_decl_index (struct lto_out_decl_state
*,
780 struct lto_output_stream
*, tree
);
781 extern void lto_output_type_ref_index (struct lto_out_decl_state
*,
782 struct lto_output_stream
*, tree
);
783 extern struct lto_simple_output_block
*lto_create_simple_output_block (
784 enum lto_section_type
);
785 extern void lto_destroy_simple_output_block (struct lto_simple_output_block
*);
786 extern struct lto_out_decl_state
*lto_new_out_decl_state (void);
787 extern void lto_delete_out_decl_state (struct lto_out_decl_state
*);
788 extern struct lto_out_decl_state
*lto_get_out_decl_state (void);
789 extern void lto_push_out_decl_state (struct lto_out_decl_state
*);
790 extern struct lto_out_decl_state
*lto_pop_out_decl_state (void);
791 extern void lto_record_function_out_decl_state (tree
,
792 struct lto_out_decl_state
*);
793 extern void lto_append_block (struct lto_output_stream
*);
796 /* In lto-streamer.c. */
797 extern const char *lto_tag_name (enum LTO_tags
);
798 extern bitmap
lto_bitmap_alloc (void);
799 extern void lto_bitmap_free (bitmap
);
800 extern char *lto_get_section_name (int, const char *, struct lto_file_decl_data
*);
801 extern void print_lto_report (const char *);
802 extern void lto_streamer_init (void);
803 extern bool gate_lto_out (void);
804 #ifdef LTO_STREAMER_DEBUG
805 extern void lto_orig_address_map (tree
, intptr_t);
806 extern intptr_t lto_orig_address_get (tree
);
807 extern void lto_orig_address_remove (tree
);
809 extern void lto_check_version (int, int);
810 extern void lto_streamer_hooks_init (void);
812 /* In lto-streamer-in.c */
813 extern void lto_input_cgraph (struct lto_file_decl_data
*, const char *);
814 extern void lto_reader_init (void);
815 extern void lto_input_function_body (struct lto_file_decl_data
*,
816 struct cgraph_node
*,
818 extern void lto_input_variable_constructor (struct lto_file_decl_data
*,
819 struct varpool_node
*,
821 extern void lto_input_constructors_and_inits (struct lto_file_decl_data
*,
823 extern void lto_input_toplevel_asms (struct lto_file_decl_data
*, int);
824 extern struct data_in
*lto_data_in_create (struct lto_file_decl_data
*,
825 const char *, unsigned,
826 vec
<ld_plugin_symbol_resolution_t
> );
827 extern void lto_data_in_delete (struct data_in
*);
828 extern void lto_input_data_block (struct lto_input_block
*, void *, size_t);
829 location_t
lto_input_location (struct bitpack_d
*, struct data_in
*);
830 tree
lto_input_tree_ref (struct lto_input_block
*, struct data_in
*,
831 struct function
*, enum LTO_tags
);
832 void lto_tag_check_set (enum LTO_tags
, int, ...);
833 void lto_init_eh (void);
834 hashval_t
lto_input_scc (struct lto_input_block
*, struct data_in
*,
835 unsigned *, unsigned *);
836 tree
lto_input_tree_1 (struct lto_input_block
*, struct data_in
*,
837 enum LTO_tags
, hashval_t hash
);
838 tree
lto_input_tree (struct lto_input_block
*, struct data_in
*);
841 /* In lto-streamer-out.c */
842 extern void lto_register_decl_definition (tree
, struct lto_file_decl_data
*);
843 extern struct output_block
*create_output_block (enum lto_section_type
);
844 extern void destroy_output_block (struct output_block
*);
845 extern void lto_output_tree (struct output_block
*, tree
, bool, bool);
846 extern void lto_output_toplevel_asms (void);
847 extern void produce_asm (struct output_block
*ob
, tree fn
);
848 extern void lto_output ();
849 extern void produce_asm_for_decls ();
850 void lto_output_decl_state_streams (struct output_block
*,
851 struct lto_out_decl_state
*);
852 void lto_output_decl_state_refs (struct output_block
*,
853 struct lto_output_stream
*,
854 struct lto_out_decl_state
*);
855 void lto_output_location (struct output_block
*, struct bitpack_d
*, location_t
);
858 /* In lto-cgraph.c */
859 extern bool asm_nodes_output
;
860 lto_symtab_encoder_t
lto_symtab_encoder_new (bool);
861 int lto_symtab_encoder_encode (lto_symtab_encoder_t
, symtab_node
*);
862 void lto_symtab_encoder_delete (lto_symtab_encoder_t
);
863 bool lto_symtab_encoder_delete_node (lto_symtab_encoder_t
, symtab_node
*);
864 bool lto_symtab_encoder_encode_body_p (lto_symtab_encoder_t
,
865 struct cgraph_node
*);
866 bool lto_symtab_encoder_in_partition_p (lto_symtab_encoder_t
,
868 void lto_set_symtab_encoder_in_partition (lto_symtab_encoder_t
,
871 bool lto_symtab_encoder_encode_initializer_p (lto_symtab_encoder_t
,
873 void output_symtab (void);
874 void input_symtab (void);
875 bool referenced_from_other_partition_p (struct ipa_ref_list
*,
876 lto_symtab_encoder_t
);
877 bool reachable_from_other_partition_p (struct cgraph_node
*,
878 lto_symtab_encoder_t
);
879 bool referenced_from_this_partition_p (struct symtab_node
*,
880 lto_symtab_encoder_t
);
881 bool reachable_from_this_partition_p (struct cgraph_node
*,
882 lto_symtab_encoder_t
);
883 lto_symtab_encoder_t
compute_ltrans_boundary (lto_symtab_encoder_t encoder
);
886 /* In lto-symtab.c. */
887 extern void lto_symtab_merge_decls (void);
888 extern void lto_symtab_merge_symbols (void);
889 extern tree
lto_symtab_prevailing_decl (tree decl
);
893 extern void lto_write_options (void);
896 /* Statistics gathered during LTO, WPA and LTRANS. */
897 extern struct lto_stats_d lto_stats
;
899 /* Section names corresponding to the values of enum lto_section_type. */
900 extern const char *lto_section_name
[];
902 /* Holds all the out decl states of functions output so far in the
903 current output file. */
904 extern vec
<lto_out_decl_state_ptr
> lto_function_decl_states
;
906 /* Return true if LTO tag TAG corresponds to a tree code. */
908 lto_tag_is_tree_code_p (enum LTO_tags tag
)
910 return tag
> LTO_tree_pickle_reference
&& (unsigned) tag
<= MAX_TREE_CODES
;
914 /* Return true if LTO tag TAG corresponds to a gimple code. */
916 lto_tag_is_gimple_code_p (enum LTO_tags tag
)
918 return (unsigned) tag
>= NUM_TREE_CODES
+ 2
919 && (unsigned) tag
< 2 + NUM_TREE_CODES
+ LAST_AND_UNUSED_GIMPLE_CODE
;
923 /* Return the LTO tag corresponding to gimple code CODE. See enum
924 LTO_tags for details on the conversion. */
925 static inline enum LTO_tags
926 lto_gimple_code_to_tag (enum gimple_code code
)
928 return (enum LTO_tags
) ((unsigned) code
+ NUM_TREE_CODES
+ 2);
932 /* Return the GIMPLE code corresponding to TAG. See enum LTO_tags for
933 details on the conversion. */
934 static inline enum gimple_code
935 lto_tag_to_gimple_code (enum LTO_tags tag
)
937 gcc_assert (lto_tag_is_gimple_code_p (tag
));
938 return (enum gimple_code
) ((unsigned) tag
- NUM_TREE_CODES
- 2);
942 /* Return the LTO tag corresponding to tree code CODE. See enum
943 LTO_tags for details on the conversion. */
944 static inline enum LTO_tags
945 lto_tree_code_to_tag (enum tree_code code
)
947 return (enum LTO_tags
) ((unsigned) code
+ 2);
951 /* Return the tree code corresponding to TAG. See enum LTO_tags for
952 details on the conversion. */
953 static inline enum tree_code
954 lto_tag_to_tree_code (enum LTO_tags tag
)
956 gcc_assert (lto_tag_is_tree_code_p (tag
));
957 return (enum tree_code
) ((unsigned) tag
- 2);
960 /* Check that tag ACTUAL == EXPECTED. */
962 lto_tag_check (enum LTO_tags actual
, enum LTO_tags expected
)
964 if (actual
!= expected
)
965 internal_error ("bytecode stream: expected tag %s instead of %s",
966 lto_tag_name (expected
), lto_tag_name (actual
));
969 /* Check that tag ACTUAL is in the range [TAG1, TAG2]. */
971 lto_tag_check_range (enum LTO_tags actual
, enum LTO_tags tag1
,
974 if (actual
< tag1
|| actual
> tag2
)
975 internal_error ("bytecode stream: tag %s is not in the expected range "
977 lto_tag_name (actual
),
979 lto_tag_name (tag2
));
982 /* Initialize an lto_out_decl_buffer ENCODER. */
984 lto_init_tree_ref_encoder (struct lto_tree_ref_encoder
*encoder
)
986 encoder
->tree_hash_table
= new hash_map
<tree
, unsigned> (251);
987 encoder
->trees
.create (0);
991 /* Destroy an lto_tree_ref_encoder ENCODER by freeing its contents. The
992 memory used by ENCODER is not freed by this function. */
994 lto_destroy_tree_ref_encoder (struct lto_tree_ref_encoder
*encoder
)
996 /* Hash table may be delete already. */
997 delete encoder
->tree_hash_table
;
998 encoder
->tree_hash_table
= NULL
;
999 encoder
->trees
.release ();
1002 /* Return the number of trees encoded in ENCODER. */
1003 static inline unsigned int
1004 lto_tree_ref_encoder_size (struct lto_tree_ref_encoder
*encoder
)
1006 return encoder
->trees
.length ();
1009 /* Return the IDX-th tree in ENCODER. */
1011 lto_tree_ref_encoder_get_tree (struct lto_tree_ref_encoder
*encoder
,
1014 return encoder
->trees
[idx
];
1017 /* Return number of encoded nodes in ENCODER. */
1019 lto_symtab_encoder_size (lto_symtab_encoder_t encoder
)
1021 return encoder
->nodes
.length ();
1024 /* Value used to represent failure of lto_symtab_encoder_lookup. */
1025 #define LCC_NOT_FOUND (-1)
1027 /* Look up NODE in encoder. Return NODE's reference if it has been encoded
1028 or LCC_NOT_FOUND if it is not there. */
1031 lto_symtab_encoder_lookup (lto_symtab_encoder_t encoder
,
1034 size_t *slot
= encoder
->map
->get (node
);
1035 return (slot
&& *slot
? *(slot
) - 1 : LCC_NOT_FOUND
);
1038 /* Return true if iterator LSE points to nothing. */
1040 lsei_end_p (lto_symtab_encoder_iterator lsei
)
1042 return lsei
.index
>= (unsigned)lto_symtab_encoder_size (lsei
.encoder
);
1045 /* Advance iterator LSE. */
1047 lsei_next (lto_symtab_encoder_iterator
*lsei
)
1052 /* Return the node pointed to by LSI. */
1053 static inline symtab_node
*
1054 lsei_node (lto_symtab_encoder_iterator lsei
)
1056 return lsei
.encoder
->nodes
[lsei
.index
].node
;
1059 /* Return the node pointed to by LSI. */
1060 static inline struct cgraph_node
*
1061 lsei_cgraph_node (lto_symtab_encoder_iterator lsei
)
1063 return dyn_cast
<cgraph_node
*> (lsei
.encoder
->nodes
[lsei
.index
].node
);
1066 /* Return the node pointed to by LSI. */
1067 static inline varpool_node
*
1068 lsei_varpool_node (lto_symtab_encoder_iterator lsei
)
1070 return dyn_cast
<varpool_node
*> (lsei
.encoder
->nodes
[lsei
.index
].node
);
1073 /* Return the cgraph node corresponding to REF using ENCODER. */
1075 static inline symtab_node
*
1076 lto_symtab_encoder_deref (lto_symtab_encoder_t encoder
, int ref
)
1078 if (ref
== LCC_NOT_FOUND
)
1081 return encoder
->nodes
[ref
].node
;
1084 /* Return an iterator to the first node in LSI. */
1085 static inline lto_symtab_encoder_iterator
1086 lsei_start (lto_symtab_encoder_t encoder
)
1088 lto_symtab_encoder_iterator lsei
;
1090 lsei
.encoder
= encoder
;
1095 /* Advance iterator LSE. */
1097 lsei_next_in_partition (lto_symtab_encoder_iterator
*lsei
)
1100 while (!lsei_end_p (*lsei
)
1101 && !lto_symtab_encoder_in_partition_p (lsei
->encoder
, lsei_node (*lsei
)))
1105 /* Return an iterator to the first node in LSI. */
1106 static inline lto_symtab_encoder_iterator
1107 lsei_start_in_partition (lto_symtab_encoder_t encoder
)
1109 lto_symtab_encoder_iterator lsei
= lsei_start (encoder
);
1111 if (lsei_end_p (lsei
))
1113 if (!lto_symtab_encoder_in_partition_p (encoder
, lsei_node (lsei
)))
1114 lsei_next_in_partition (&lsei
);
1119 /* Advance iterator LSE. */
1121 lsei_next_function_in_partition (lto_symtab_encoder_iterator
*lsei
)
1124 while (!lsei_end_p (*lsei
)
1125 && (!is_a
<cgraph_node
*> (lsei_node (*lsei
))
1126 || !lto_symtab_encoder_in_partition_p (lsei
->encoder
, lsei_node (*lsei
))))
1130 /* Return an iterator to the first node in LSI. */
1131 static inline lto_symtab_encoder_iterator
1132 lsei_start_function_in_partition (lto_symtab_encoder_t encoder
)
1134 lto_symtab_encoder_iterator lsei
= lsei_start (encoder
);
1136 if (lsei_end_p (lsei
))
1138 if (!is_a
<cgraph_node
*> (lsei_node (lsei
))
1139 || !lto_symtab_encoder_in_partition_p (encoder
, lsei_node (lsei
)))
1140 lsei_next_function_in_partition (&lsei
);
1145 /* Advance iterator LSE. */
1147 lsei_next_variable_in_partition (lto_symtab_encoder_iterator
*lsei
)
1150 while (!lsei_end_p (*lsei
)
1151 && (!is_a
<varpool_node
*> (lsei_node (*lsei
))
1152 || !lto_symtab_encoder_in_partition_p (lsei
->encoder
, lsei_node (*lsei
))))
1156 /* Return an iterator to the first node in LSI. */
1157 static inline lto_symtab_encoder_iterator
1158 lsei_start_variable_in_partition (lto_symtab_encoder_t encoder
)
1160 lto_symtab_encoder_iterator lsei
= lsei_start (encoder
);
1162 if (lsei_end_p (lsei
))
1164 if (!is_a
<varpool_node
*> (lsei_node (lsei
))
1165 || !lto_symtab_encoder_in_partition_p (encoder
, lsei_node (lsei
)))
1166 lsei_next_variable_in_partition (&lsei
);
1171 DEFINE_DECL_STREAM_FUNCS (TYPE
, type
)
1172 DEFINE_DECL_STREAM_FUNCS (FIELD_DECL
, field_decl
)
1173 DEFINE_DECL_STREAM_FUNCS (FN_DECL
, fn_decl
)
1174 DEFINE_DECL_STREAM_FUNCS (VAR_DECL
, var_decl
)
1175 DEFINE_DECL_STREAM_FUNCS (TYPE_DECL
, type_decl
)
1176 DEFINE_DECL_STREAM_FUNCS (NAMESPACE_DECL
, namespace_decl
)
1177 DEFINE_DECL_STREAM_FUNCS (LABEL_DECL
, label_decl
)
1179 #endif /* GCC_LTO_STREAMER_H */