1/* Data structures and declarations used for reading and writing
2 GIMPLE to a file stream.
3
4 Copyright (C) 2009-2022 Free Software Foundation, Inc.
5 Contributed by Doug Kwan <dougkwan@google.com>
6
7This file is part of GCC.
8
9GCC is free software; you can redistribute it and/or modify it under
10the terms of the GNU General Public License as published by the Free
11Software Foundation; either version 3, or (at your option) any later
12version.
13
14GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15WARRANTY; without even the implied warranty of MERCHANTABILITY or
16FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17for more details.
18
19You should have received a copy of the GNU General Public License
20along with GCC; see the file COPYING3. If not see
21<http://www.gnu.org/licenses/>. */
22
23#ifndef GCC_LTO_STREAMER_H
24#define GCC_LTO_STREAMER_H
25
26#include "plugin-api.h"
27#include "gcov-io.h"
28#include "diagnostic.h"
29#include "version.h"
30
31/* The encoding for a function consists of the following sections:
32
33 1) The header.
34 2) FIELD_DECLS.
35 3) FUNCTION_DECLS.
36 4) global VAR_DECLS.
37 5) type_decls
38 6) types.
39 7) Names for the labels that have names
40 8) The SSA names.
41 9) The control flow graph.
42 10-11)Gimple for local decls.
43 12) Gimple for the function.
44 13) Strings.
45
46 1) THE HEADER.
47 2-6) THE GLOBAL DECLS AND TYPES.
48
49 The global decls and types are encoded in the same way. For each
50 entry, there is word with the offset within the section to the
51 entry.
52
53 7) THE LABEL NAMES.
54
55 Since most labels do not have names, this section my be of zero
56 length. It consists of an array of string table references, one
57 per label. In the lto code, the labels are given either
58 positive or negative indexes. the positive ones have names and
59 the negative ones do not. The positive index can be used to
60 find the name in this array.
61
62 9) THE CFG.
63
64 10) Index into the local decls. Since local decls can have local
65 decls inside them, they must be read in randomly in order to
66 properly restore them.
67
68 11-12) GIMPLE FOR THE LOCAL DECLS AND THE FUNCTION BODY.
69
70 The gimple consists of a set of records.
71
72 THE FUNCTION
73
74 At the top level of (8) is the function. It consists of five
75 pieces:
76
77 LTO_function - The tag.
78 eh tree - This is all of the exception handling regions
79 put out in a post order traversial of the
80 tree. Siblings are output as lists terminated
81 by a 0. The set of fields matches the fields
82 defined in except.cc.
83
84 last_basic_block - in uleb128 form.
85
86 basic blocks - This is the set of basic blocks.
87
88 zero - The termination of the basic blocks.
89
90 BASIC BLOCKS
91
92 There are two forms of basic blocks depending on if they are
93 empty or not.
94
95 The basic block consists of:
96
97 LTO_bb1 or LTO_bb0 - The tag.
98
99 bb->index - the index in uleb128 form.
100
101 #succs - The number of successors un uleb128 form.
102
103 the successors - For each edge, a pair. The first of the
104 pair is the index of the successor in
105 uleb128 form and the second are the flags in
106 uleb128 form.
107
108 the statements - A gimple tree, as described above.
109 These are only present for LTO_BB1.
110 Following each statement is an optional
111 exception handling record LTO_eh_region
112 which contains the region number (for
113 regions >= 0).
114
115 zero - This is only present for LTO_BB1 and is used
116 to terminate the statements and exception
117 regions within this block.
118
119 12) STRINGS
120
121 String are represented in the table as pairs, a length in ULEB128
122 form followed by the data for the string. */
123
124#define LTO_major_version GCC_major_version
125#define LTO_minor_version 0
126
127typedef unsigned char lto_decl_flags_t;
128
129/* Stream additional data to LTO object files to make it easier to debug
130 streaming code. This changes object files. */
131static const bool streamer_debugging = false;
132
133/* Tags representing the various IL objects written to the bytecode file
134 (GIMPLE statements, basic blocks, EH regions, tree nodes, etc).
135
136 NOTE, when adding new LTO tags, also update lto_tag_name. */
137enum LTO_tags
138{
139 LTO_null = 0,
140
141 /* Reference to previously-streamed node. */
142 LTO_tree_pickle_reference,
143
144 /* References to indexable tree nodes. These objects are stored in
145 tables that are written separately from the function bodies
146 and variable constructors that reference them. This way they can be
147 instantiated even when the referencing functions aren't (e.g., during WPA)
148 and it also allows functions to be copied from one file to another without
149 having to unpickle the body first (the references are location
150 independent). */
151 LTO_global_stream_ref,
152
153 LTO_ssa_name_ref,
154
155 /* Special for global streamer. A blob of unnamed tree nodes. */
156 LTO_tree_scc,
157
158 /* Sequence of trees. */
159 LTO_trees,
160
161 /* Shared INTEGER_CST node. */
162 LTO_integer_cst,
163
164 /* Tags of trees are encoded as
165 LTO_first_tree_tag + TREE_CODE. */
166 LTO_first_tree_tag,
167 /* Tags of gimple typles are encoded as
168 LTO_first_gimple_tag + gimple_code. */
169 LTO_first_gimple_tag = LTO_first_tree_tag + MAX_TREE_CODES,
170
171 /* Entry and exit basic blocks. */
172 LTO_bb0 = LTO_first_gimple_tag + LAST_AND_UNUSED_GIMPLE_CODE,
173 LTO_bb1,
174
175 /* EH region holding the previous statement. */
176 LTO_eh_region,
177
178 /* Function body. */
179 LTO_function,
180
181 /* EH table. */
182 LTO_eh_table,
183
184 /* EH region types. These mirror enum eh_region_type. */
185 LTO_ert_cleanup,
186 LTO_ert_try,
187 LTO_ert_allowed_exceptions,
188 LTO_ert_must_not_throw,
189
190 /* EH landing pad. */
191 LTO_eh_landing_pad,
192
193 /* EH try/catch node. */
194 LTO_eh_catch,
195
196 /* This tag must always be last. */
197 LTO_NUM_TAGS
198};
199
200
201/* Set of section types that are in an LTO file. This list will grow
202 as the number of IPA passes grows since each IPA pass will need its
203 own section type to store its summary information.
204
205 When adding a new section type, you must also extend the
206 LTO_SECTION_NAME array in lto-section-in.cc. */
207enum lto_section_type
208{
209 LTO_section_decls = 0,
210 LTO_section_function_body,
211 LTO_section_static_initializer,
212 LTO_section_symtab,
213 LTO_section_symtab_extension,
214 LTO_section_refs,
215 LTO_section_asm,
216 LTO_section_jump_functions,
217 LTO_section_ipa_pure_const,
218 LTO_section_ipa_reference,
219 LTO_section_ipa_profile,
220 LTO_section_symtab_nodes,
221 LTO_section_opts,
222 LTO_section_cgraph_opt_sum,
223 LTO_section_ipa_fn_summary,
224 LTO_section_ipcp_transform,
225 LTO_section_ipa_icf,
226 LTO_section_offload_table,
227 LTO_section_mode_table,
228 LTO_section_lto,
229 LTO_section_ipa_sra,
230 LTO_section_odr_types,
231 LTO_section_ipa_modref,
232 LTO_N_SECTION_TYPES /* Must be last. */
233};
234
235/* Indices to the various function, type and symbol streams. */
236enum lto_decl_stream_e_t
237{
238 LTO_DECL_STREAM = 0, /* Must be first. */
239 LTO_N_DECL_STREAMS
240};
241
242typedef enum ld_plugin_symbol_resolution ld_plugin_symbol_resolution_t;
243
244/* Return a char pointer to the start of a data stream for an lto pass
245 or function. The first parameter is the file data that contains
246 the information. The second parameter is the type of information
247 to be obtained. The third parameter is the name of the function
248 and is only used when finding a function body; otherwise it is
249 NULL. The fourth parameter is the length of the data returned. */
250typedef const char* (lto_get_section_data_f) (struct lto_file_decl_data *,
251 enum lto_section_type,
252 const char *,
253 int,
254 size_t *);
255
256/* Return the data found from the above call. The first three
257 parameters are the same as above. The fourth parameter is the data
258 itself and the fifth is the length of the data. */
259typedef void (lto_free_section_data_f) (struct lto_file_decl_data *,
260 enum lto_section_type,
261 const char *,
262 const char *,
263 size_t);
264
265/* The location cache holds expanded locations for streamed in trees.
266 This is done to reduce memory usage of libcpp linemap that strongly prefers
267 locations to be inserted in the source order. */
268
269class lto_location_cache
270{
271public:
272 /* Apply all changes in location cache. Add locations into linemap and patch
273 trees. */
274 bool apply_location_cache ();
275 /* Tree merging did not suceed; mark all changes in the cache as accepted. */
276 void accept_location_cache ();
277 /* Tree merging did suceed; throw away recent changes. */
278 void revert_location_cache ();
279 void input_location (location_t *loc, struct bitpack_d *bp,
280 class data_in *data_in);
281 void input_location_and_block (location_t *loc, struct bitpack_d *bp,
282 class lto_input_block *ib,
283 class data_in *data_in);
284 lto_location_cache ()
285 : loc_cache (), accepted_length (0), current_file (NULL), current_line (0),
286 current_col (0), current_sysp (false), current_loc (UNKNOWN_LOCATION),
287 current_block (NULL_TREE)
288 {
289 gcc_assert (!current_cache);
290 current_cache = this;
291 }
292 ~lto_location_cache ()
293 {
294 apply_location_cache ();
295 gcc_assert (current_cache == this);
296 current_cache = NULL;
297 }
298
299 /* There can be at most one instance of location cache (combining multiple
300 would bring it out of sync with libcpp linemap); point to current
301 one. */
302 static lto_location_cache *current_cache;
303
304private:
305 static int cmp_loc (const void *pa, const void *pb);
306
307 struct cached_location
308 {
309 const char *file;
310 location_t *loc;
311 int line, col;
312 bool sysp;
313 tree block;
314 };
315
316 /* The location cache. */
317
318 auto_vec<cached_location> loc_cache;
319
320 /* Accepted entries are ones used by trees that are known to be not unified
321 by tree merging. */
322
323 int accepted_length;
324
325 /* Bookkeeping to remember state in between calls to lto_apply_location_cache
326 When streaming gimple, the location cache is not used and thus
327 lto_apply_location_cache happens per location basis. It is then
328 useful to avoid redundant calls of linemap API. */
329
330 const char *current_file;
331 int current_line;
332 int current_col;
333 bool current_sysp;
334 location_t current_loc;
335 tree current_block;
336};
337
338/* Structure used as buffer for reading an LTO file. */
339class lto_input_block
340{
341public:
342 /* Special constructor for the string table, it abuses this to
343 do random access but use the uhwi decoder. */
344 lto_input_block (const char *data_, unsigned int p_, unsigned int len_,
345 const unsigned char *mode_table_)
346 : data (data_), mode_table (mode_table_), p (p_), len (len_) {}
347 lto_input_block (const char *data_, unsigned int len_,
348 const unsigned char *mode_table_)
349 : data (data_), mode_table (mode_table_), p (0), len (len_) {}
350
351 const char *data;
352 const unsigned char *mode_table;
353 unsigned int p;
354 unsigned int len;
355};
356
357/* Compression algorithm used for compression of LTO bytecode. */
358
359enum lto_compression
360{
361 ZLIB,
362 ZSTD
363};
364
365/* Structure that represents LTO ELF section with information
366 about the format. */
367
368struct lto_section
369{
370 int16_t major_version;
371 int16_t minor_version;
372 unsigned char slim_object;
373 unsigned char _padding;
374
375 /* Flags is a private field that is not defined publicly. */
376 uint16_t flags;
377
378 /* Set compression to FLAGS. */
379 inline void set_compression (lto_compression c)
380 {
381 flags = c;
382 }
383
384 /* Get compression from FLAGS. */
385 inline lto_compression get_compression ()
386 {
387 return (lto_compression) flags;
388 }
389};
390
391STATIC_ASSERT (sizeof (lto_section) == 8);
392
393/* The is the first part of the record in an LTO file for many of the
394 IPA passes. */
395struct lto_simple_header
396{
397 /* Size of main gimple body of function. */
398 int32_t main_size;
399};
400
401struct lto_simple_header_with_strings : lto_simple_header
402{
403 /* Size of the string table. */
404 int32_t string_size;
405};
406
407/* The header for a function body. */
408struct lto_function_header : lto_simple_header_with_strings
409{
410 /* Size of the cfg. */
411 int32_t cfg_size;
412};
413
414
415/* Structure describing a symbol section. */
416struct lto_decl_header : lto_simple_header_with_strings
417{
418 /* Size of region for decl state. */
419 int32_t decl_state_size;
420
421 /* Number of nodes in globals stream. */
422 int32_t num_nodes;
423};
424
425
426/* Statistics gathered during LTO, WPA and LTRANS. */
427struct lto_stats_d
428{
429 unsigned HOST_WIDE_INT num_input_cgraph_nodes;
430 unsigned HOST_WIDE_INT num_output_symtab_nodes;
431 unsigned HOST_WIDE_INT num_input_files;
432 unsigned HOST_WIDE_INT num_output_files;
433 unsigned HOST_WIDE_INT num_cgraph_partitions;
434 unsigned HOST_WIDE_INT section_size[LTO_N_SECTION_TYPES];
435 unsigned HOST_WIDE_INT num_function_bodies;
436 unsigned HOST_WIDE_INT num_trees[NUM_TREE_CODES];
437 unsigned HOST_WIDE_INT num_output_il_bytes;
438 unsigned HOST_WIDE_INT num_compressed_il_bytes;
439 unsigned HOST_WIDE_INT num_input_il_bytes;
440 unsigned HOST_WIDE_INT num_uncompressed_il_bytes;
441 unsigned HOST_WIDE_INT num_tree_bodies_output;
442 unsigned HOST_WIDE_INT num_pickle_refs_output;
443};
444
445/* Entry of LTO symtab encoder. */
446struct lto_encoder_entry
447{
448 symtab_node *node;
449 /* Is the node in this partition (i.e. ltrans of this partition will
450 be responsible for outputting it)? */
451 unsigned int in_partition:1;
452 /* Do we encode body in this partition? */
453 unsigned int body:1;
454 /* Do we encode initializer in this partition?
455 For example the readonly variable initializers are encoded to aid
456 constant folding even if they are not in the partition. */
457 unsigned int initializer:1;
458};
459
460
461/* Encoder data structure used to stream callgraph nodes. */
462struct lto_symtab_encoder_d
463{
464 vec<lto_encoder_entry> nodes;
465 hash_map<symtab_node *, size_t> *map;
466};
467
468typedef struct lto_symtab_encoder_d *lto_symtab_encoder_t;
469
470/* Iterator structure for cgraph node sets. */
471struct lto_symtab_encoder_iterator
472{
473 lto_symtab_encoder_t encoder;
474 unsigned index;
475};
476
477
478
479/* The lto_tree_ref_encoder struct is used to encode trees into indices. */
480
481struct lto_tree_ref_encoder
482{
483 hash_map<tree, unsigned> *tree_hash_table; /* Maps pointers to indices. */
484 vec<tree> trees; /* Maps indices to pointers. */
485};
486
487
488/* Structure to hold states of input scope. */
489struct GTY((for_user)) lto_in_decl_state
490{
491 /* Array of lto_in_decl_buffers to store type and decls streams. */
492 vec<tree, va_gc> *streams[LTO_N_DECL_STREAMS];
493
494 /* If this in-decl state is associated with a function. FN_DECL
495 point to the FUNCTION_DECL. */
496 tree fn_decl;
497
498 /* True if decl state is compressed. */
499 bool compressed;
500};
501
502typedef struct lto_in_decl_state *lto_in_decl_state_ptr;
503
504struct decl_state_hasher : ggc_ptr_hash<lto_in_decl_state>
505{
506 static hashval_t
507 hash (lto_in_decl_state *s)
508 {
509 return htab_hash_pointer (s->fn_decl);
510 }
511
512 static bool
513 equal (lto_in_decl_state *a, lto_in_decl_state *b)
514 {
515 return a->fn_decl == b->fn_decl;
516 }
517};
518
519/* The structure that holds all of the vectors of global types,
520 decls and cgraph nodes used in the serialization of this file. */
521struct lto_out_decl_state
522{
523 /* The buffers contain the sets of decls of various kinds and types we have
524 seen so far and the indexes assigned to them. */
525 struct lto_tree_ref_encoder streams[LTO_N_DECL_STREAMS];
526
527 /* Encoder for cgraph nodes. */
528 lto_symtab_encoder_t symtab_node_encoder;
529
530 /* If this out-decl state belongs to a function, fn_decl points to that
531 function. Otherwise, it is NULL. */
532 tree fn_decl;
533
534 /* True if decl state is compressed. */
535 bool compressed;
536};
537
538typedef struct lto_out_decl_state *lto_out_decl_state_ptr;
539
540
541/* Compact representation of a index <-> resolution pair. Unpacked to an
542 vector later. */
543struct res_pair
544{
545 ld_plugin_symbol_resolution_t res;
546 unsigned index;
547};
548
549
550/* One of these is allocated for each object file that being compiled
551 by lto. This structure contains the tables that are needed by the
552 serialized functions and ipa passes to connect themselves to the
553 global types and decls as they are reconstituted. */
554struct GTY(()) lto_file_decl_data
555{
556 /* Decl state currently used. */
557 struct lto_in_decl_state *current_decl_state;
558
559 /* Decl state corresponding to regions outside of any functions
560 in the compilation unit. */
561 struct lto_in_decl_state *global_decl_state;
562
563 /* Table of cgraph nodes present in this file. */
564 lto_symtab_encoder_t GTY((skip)) symtab_node_encoder;
565
566 /* Hash table maps lto-related section names to location in file. */
567 hash_table<decl_state_hasher> *function_decl_states;
568
569 /* The .o file that these offsets relate to. */
570 const char *GTY((skip)) file_name;
571
572 /* Hash table maps lto-related section names to location in file. */
573 htab_t GTY((skip)) section_hash_table;
574
575 /* Hash new name of renamed global declaration to its original name. */
576 htab_t GTY((skip)) renaming_hash_table;
577
578 /* Linked list used temporarily in reader */
579 struct lto_file_decl_data *next;
580
581 /* Order in which the file appears on the command line. */
582 int order;
583
584 /* Sub ID for merged objects. */
585 unsigned HOST_WIDE_INT id;
586
587 /* Symbol resolutions for this file */
588 vec<res_pair> GTY((skip)) respairs;
589 unsigned max_index;
590
591 gcov_summary GTY((skip)) profile_info;
592
593 /* Map assigning declarations their resolutions. */
594 hash_map<tree, ld_plugin_symbol_resolution> * GTY((skip)) resolution_map;
595
596 /* Mode translation table. */
597 const unsigned char *mode_table;
598
599 /* Read LTO section. */
600 lto_section lto_section_header;
601
602 int order_base;
603
604 int unit_base;
605};
606
607typedef struct lto_file_decl_data *lto_file_decl_data_ptr;
608
609struct lto_char_ptr_base
610{
611 char *ptr;
612};
613
614/* An incore byte stream to buffer the various parts of the function.
615 The entire structure should be zeroed when created. The record
616 consists of a set of blocks. The first sizeof (ptr) bytes are used
617 as a chain, and the rest store the bytes to be written. */
618struct lto_output_stream
619{
620 /* The pointer to the first block in the stream. */
621 struct lto_char_ptr_base * first_block;
622
623 /* The pointer to the last and current block in the stream. */
624 struct lto_char_ptr_base * current_block;
625
626 /* The pointer to where the next char should be written. */
627 char * current_pointer;
628
629 /* The number of characters left in the current block. */
630 unsigned int left_in_block;
631
632 /* The block size of the last block allocated. */
633 unsigned int block_size;
634
635 /* The total number of characters written. */
636 unsigned int total_size;
637};
638
639/* A simple output block. This can be used for simple IPA passes that
640 do not need more than one stream. */
641struct lto_simple_output_block
642{
643 enum lto_section_type section_type;
644 struct lto_out_decl_state *decl_state;
645
646 /* The stream that the main tree codes are written to. */
647 struct lto_output_stream *main_stream;
648};
649
650/* String hashing. */
651
652struct string_slot
653{
654 const char *s;
655 int len;
656 unsigned int slot_num;
657};
658
659/* Hashtable helpers. */
660
661struct string_slot_hasher : nofree_ptr_hash <string_slot>
662{
663 static inline hashval_t hash (const string_slot *);
664 static inline bool equal (const string_slot *, const string_slot *);
665};
666
667/* Returns a hash code for DS. Adapted from libiberty's htab_hash_string
668 to support strings that may not end in '\0'. */
669
670inline hashval_t
671string_slot_hasher::hash (const string_slot *ds)
672{
673 hashval_t r = ds->len;
674 int i;
675
676 for (i = 0; i < ds->len; i++)
677 r = r * 67 + (unsigned)ds->s[i] - 113;
678 return r;
679}
680
681/* Returns nonzero if DS1 and DS2 are equal. */
682
683inline bool
684string_slot_hasher::equal (const string_slot *ds1, const string_slot *ds2)
685{
686 if (ds1->len == ds2->len)
687 return memcmp (ds1->s, ds2->s, ds1->len) == 0;
688
689 return 0;
690}
691
692/* Data structure holding all the data and descriptors used when writing
693 an LTO file. */
694struct output_block
695{
696 enum lto_section_type section_type;
697 struct lto_out_decl_state *decl_state;
698
699 /* The stream that the main tree codes are written to. */
700 struct lto_output_stream *main_stream;
701
702 /* The stream that contains the string table. */
703 struct lto_output_stream *string_stream;
704
705 /* The stream that contains the cfg. */
706 struct lto_output_stream *cfg_stream;
707
708 /* The hash table that contains the set of strings we have seen so
709 far and the indexes assigned to them. */
710 hash_table<string_slot_hasher> *string_hash_table;
711
712 /* The current symbol that we are currently serializing. Null
713 if we are serializing something else. */
714 symtab_node *symbol;
715
716 /* These are the last file and line that were seen in the stream.
717 If the current node differs from these, it needs to insert
718 something into the stream and fix these up. */
719 const char *current_file;
720 int current_line;
721 int current_col;
722 bool current_sysp;
723 bool reset_locus;
724 bool emit_pwd;
725 tree current_block;
726
727 /* Cache of nodes written in this section. */
728 struct streamer_tree_cache_d *writer_cache;
729
730 /* All trees identified as local to the unit streamed. */
731 hash_set<tree> *local_trees;
732
733 /* All data persistent across whole duration of output block
734 can go here. */
735 struct obstack obstack;
736};
737
738
739/* Data and descriptors used when reading from an LTO file. */
740class data_in
741{
742public:
743 /* The global decls and types. */
744 struct lto_file_decl_data *file_data;
745
746 /* The string table. */
747 const char *strings;
748
749 /* The length of the string table. */
750 unsigned int strings_len;
751
752 /* Maps each reference number to the resolution done by the linker. */
753 vec<ld_plugin_symbol_resolution_t> globals_resolution;
754
755 /* Cache of pickled nodes. */
756 struct streamer_tree_cache_d *reader_cache;
757
758 /* Cache of source code location. */
759 lto_location_cache location_cache;
760};
761
762
763/* In lto-section-in.cc */
764extern class lto_input_block * lto_create_simple_input_block (
765 struct lto_file_decl_data *,
766 enum lto_section_type, const char **, size_t *);
767extern void
768lto_destroy_simple_input_block (struct lto_file_decl_data *,
769 enum lto_section_type,
770 class lto_input_block *, const char *, size_t);
771extern void lto_set_in_hooks (struct lto_file_decl_data **,
772 lto_get_section_data_f *,
773 lto_free_section_data_f *);
774extern struct lto_file_decl_data **lto_get_file_decl_data (void);
775extern const char *lto_get_section_data (struct lto_file_decl_data *,
776 enum lto_section_type,
777 const char *, int, size_t *,
778 bool decompress = false);
779extern const char *lto_get_summary_section_data (struct lto_file_decl_data *,
780 enum lto_section_type,
781 size_t *);
782extern const char *lto_get_raw_section_data (struct lto_file_decl_data *,
783 enum lto_section_type,
784 const char *, int, size_t *);
785extern void lto_free_section_data (struct lto_file_decl_data *,
786 enum lto_section_type,
787 const char *, const char *, size_t,
788 bool decompress = false);
789extern void lto_free_raw_section_data (struct lto_file_decl_data *,
790 enum lto_section_type,
791 const char *, const char *, size_t);
792extern htab_t lto_create_renaming_table (void);
793extern void lto_record_renamed_decl (struct lto_file_decl_data *,
794 const char *, const char *);
795extern const char *lto_get_decl_name_mapping (struct lto_file_decl_data *,
796 const char *);
797extern struct lto_in_decl_state *lto_new_in_decl_state (void);
798extern void lto_delete_in_decl_state (struct lto_in_decl_state *);
799extern struct lto_in_decl_state *lto_get_function_in_decl_state (
800 struct lto_file_decl_data *, tree);
801extern void lto_free_function_in_decl_state (struct lto_in_decl_state *);
802extern void lto_free_function_in_decl_state_for_node (symtab_node *);
803extern void lto_section_overrun (class lto_input_block *) ATTRIBUTE_NORETURN;
804extern void lto_value_range_error (const char *,
805 HOST_WIDE_INT, HOST_WIDE_INT,
806 HOST_WIDE_INT) ATTRIBUTE_NORETURN;
807
808/* In lto-section-out.cc */
809extern void lto_begin_section (const char *, bool);
810extern void lto_end_section (void);
811extern void lto_write_data (const void *, unsigned int);
812extern void lto_write_raw_data (const void *, unsigned int);
813extern void lto_write_stream (struct lto_output_stream *);
814extern struct lto_simple_output_block *lto_create_simple_output_block (
815 enum lto_section_type);
816extern void lto_destroy_simple_output_block (struct lto_simple_output_block *);
817extern struct lto_out_decl_state *lto_new_out_decl_state (void);
818extern void lto_delete_out_decl_state (struct lto_out_decl_state *);
819extern struct lto_out_decl_state *lto_get_out_decl_state (void);
820extern void lto_push_out_decl_state (struct lto_out_decl_state *);
821extern struct lto_out_decl_state *lto_pop_out_decl_state (void);
822extern void lto_record_function_out_decl_state (tree,
823 struct lto_out_decl_state *);
824extern void lto_append_block (struct lto_output_stream *);
825
826
827/* In lto-streamer.cc. */
828
829/* Set when streaming LTO for offloading compiler. */
830extern bool lto_stream_offload_p;
831
832extern const char *lto_tag_name (enum LTO_tags);
833extern char *lto_get_section_name (int, const char *, int,
834 struct lto_file_decl_data *);
835extern void print_lto_report (const char *);
836extern void lto_streamer_init (void);
837extern bool gate_lto_out (void);
838extern void lto_check_version (int, int, const char *);
839extern void lto_streamer_hooks_init (void);
840
841/* In lto-streamer-in.cc */
842extern void lto_input_cgraph (struct lto_file_decl_data *, const char *);
843extern void lto_reader_init (void);
844extern void lto_free_file_name_hash (void);
845extern void lto_input_function_body (struct lto_file_decl_data *,
846 struct cgraph_node *,
847 const char *);
848extern void lto_input_variable_constructor (struct lto_file_decl_data *,
849 struct varpool_node *,
850 const char *);
851extern void lto_input_constructors_and_inits (struct lto_file_decl_data *,
852 const char *);
853extern void lto_input_toplevel_asms (struct lto_file_decl_data *, int);
854extern void lto_input_mode_table (struct lto_file_decl_data *);
855extern class data_in *lto_data_in_create (struct lto_file_decl_data *,
856 const char *, unsigned,
857 vec<ld_plugin_symbol_resolution_t> );
858extern void lto_data_in_delete (class data_in *);
859extern void lto_input_data_block (class lto_input_block *, void *, size_t);
860void lto_input_location (location_t *, struct bitpack_d *, class data_in *);
861tree lto_input_tree_ref (class lto_input_block *, class data_in *,
862 struct function *, enum LTO_tags);
863void lto_tag_check_set (enum LTO_tags, int, ...);
864void lto_init_eh (void);
865hashval_t lto_input_scc (class lto_input_block *, class data_in *,
866 unsigned *, unsigned *, bool);
867tree lto_input_tree_1 (class lto_input_block *, class data_in *,
868 enum LTO_tags, hashval_t hash);
869tree lto_input_tree (class lto_input_block *, class data_in *);
870tree stream_read_tree_ref (class lto_input_block *, class data_in *);
871
872
873/* In lto-streamer-out.cc */
874extern void lto_register_decl_definition (tree, struct lto_file_decl_data *);
875extern struct output_block *create_output_block (enum lto_section_type);
876extern void destroy_output_block (struct output_block *);
877extern void lto_output_tree (struct output_block *, tree, bool, bool);
878extern void stream_write_tree_ref (struct output_block *, tree);
879extern void lto_output_var_decl_ref (struct lto_out_decl_state *,
880 struct lto_output_stream *, tree);
881extern void lto_output_fn_decl_ref (struct lto_out_decl_state *,
882 struct lto_output_stream *, tree);
883extern tree lto_input_var_decl_ref (lto_input_block *, lto_file_decl_data *);
884extern tree lto_input_fn_decl_ref (lto_input_block *, lto_file_decl_data *);
885extern void lto_output_toplevel_asms (void);
886extern void produce_asm (struct output_block *ob, tree fn);
887extern void lto_output ();
888extern void produce_asm_for_decls ();
889void lto_output_decl_state_streams (struct output_block *,
890 struct lto_out_decl_state *);
891void lto_output_decl_state_refs (struct output_block *,
892 struct lto_output_stream *,
893 struct lto_out_decl_state *);
894void lto_output_location (struct output_block *, struct bitpack_d *,
895 location_t);
896void lto_output_location_and_block (struct output_block *, struct bitpack_d *,
897 location_t);
898void lto_output_init_mode_table (void);
899void lto_prepare_function_for_streaming (cgraph_node *);
900
901
902/* In lto-cgraph.cc */
903extern bool asm_nodes_output;
904lto_symtab_encoder_t lto_symtab_encoder_new (bool);
905int lto_symtab_encoder_encode (lto_symtab_encoder_t, symtab_node *);
906void lto_symtab_encoder_delete (lto_symtab_encoder_t);
907bool lto_symtab_encoder_delete_node (lto_symtab_encoder_t, symtab_node *);
908bool lto_symtab_encoder_encode_body_p (lto_symtab_encoder_t,
909 struct cgraph_node *);
910bool lto_symtab_encoder_in_partition_p (lto_symtab_encoder_t,
911 symtab_node *);
912void lto_set_symtab_encoder_in_partition (lto_symtab_encoder_t,
913 symtab_node *);
914
915bool lto_symtab_encoder_encode_initializer_p (lto_symtab_encoder_t,
916 varpool_node *);
917void output_symtab (void);
918void input_symtab (void);
919void output_offload_tables (void);
920void input_offload_tables (bool);
921bool referenced_from_other_partition_p (struct ipa_ref_list *,
922 lto_symtab_encoder_t);
923bool reachable_from_other_partition_p (struct cgraph_node *,
924 lto_symtab_encoder_t);
925bool referenced_from_this_partition_p (symtab_node *,
926 lto_symtab_encoder_t);
927bool reachable_from_this_partition_p (struct cgraph_node *,
928 lto_symtab_encoder_t);
929lto_symtab_encoder_t compute_ltrans_boundary (lto_symtab_encoder_t encoder);
930void select_what_to_stream (void);
931
932/* In omp-general.cc. */
933void omp_lto_output_declare_variant_alt (lto_simple_output_block *,
934 cgraph_node *, lto_symtab_encoder_t);
935void omp_lto_input_declare_variant_alt (lto_input_block *, cgraph_node *,
936 vec<symtab_node *>);
937
938/* In options-save.cc. */
939void cl_target_option_stream_out (struct output_block *, struct bitpack_d *,
940 struct cl_target_option *);
941
942void cl_target_option_stream_in (class data_in *,
943 struct bitpack_d *,
944 struct cl_target_option *);
945
946void cl_optimization_stream_out (struct output_block *,
947 struct bitpack_d *, struct cl_optimization *);
948
949void cl_optimization_stream_in (class data_in *,
950 struct bitpack_d *, struct cl_optimization *);
951
952
953
954/* In lto-opts.cc. */
955extern void lto_write_options (void);
956
957
958/* Statistics gathered during LTO, WPA and LTRANS. */
959extern struct lto_stats_d lto_stats;
960
961/* Section names corresponding to the values of enum lto_section_type. */
962extern const char *lto_section_name[];
963
964/* Holds all the out decl states of functions output so far in the
965 current output file. */
966extern vec<lto_out_decl_state_ptr> lto_function_decl_states;
967
968/* Return true if LTO tag TAG corresponds to a tree code. */
969static inline bool
970lto_tag_is_tree_code_p (enum LTO_tags tag)
971{
972 return tag > LTO_first_tree_tag && (unsigned) tag <= MAX_TREE_CODES;
973}
974
975
976/* Return true if LTO tag TAG corresponds to a gimple code. */
977static inline bool
978lto_tag_is_gimple_code_p (enum LTO_tags tag)
979{
980 return (unsigned) tag >= LTO_first_gimple_tag
981 && (unsigned) tag
982 < LTO_first_gimple_tag + LAST_AND_UNUSED_GIMPLE_CODE;
983}
984
985
986/* Return the LTO tag corresponding to gimple code CODE. See enum
987 LTO_tags for details on the conversion. */
988static inline enum LTO_tags
989lto_gimple_code_to_tag (enum gimple_code code)
990{
991 return (enum LTO_tags) ((unsigned) code + LTO_first_gimple_tag);
992}
993
994
995/* Return the GIMPLE code corresponding to TAG. See enum LTO_tags for
996 details on the conversion. */
997static inline enum gimple_code
998lto_tag_to_gimple_code (enum LTO_tags tag)
999{
1000 gcc_assert (lto_tag_is_gimple_code_p (tag));
1001 return (enum gimple_code) ((unsigned) tag - LTO_first_gimple_tag);
1002}
1003
1004
1005/* Return the LTO tag corresponding to tree code CODE. See enum
1006 LTO_tags for details on the conversion. */
1007static inline enum LTO_tags
1008lto_tree_code_to_tag (enum tree_code code)
1009{
1010 return (enum LTO_tags) ((unsigned) code + LTO_first_tree_tag);
1011}
1012
1013
1014/* Return the tree code corresponding to TAG. See enum LTO_tags for
1015 details on the conversion. */
1016static inline enum tree_code
1017lto_tag_to_tree_code (enum LTO_tags tag)
1018{
1019 gcc_assert (lto_tag_is_tree_code_p (tag));
1020 return (enum tree_code) ((unsigned) tag - LTO_first_tree_tag);
1021}
1022
1023/* Check that tag ACTUAL == EXPECTED. */
1024static inline void
1025lto_tag_check (enum LTO_tags actual, enum LTO_tags expected)
1026{
1027 if (actual != expected)
1028 internal_error ("bytecode stream: expected tag %s instead of %s",
1029 lto_tag_name (expected), lto_tag_name (actual));
1030}
1031
1032/* Check that tag ACTUAL is in the range [TAG1, TAG2]. */
1033static inline void
1034lto_tag_check_range (enum LTO_tags actual, enum LTO_tags tag1,
1035 enum LTO_tags tag2)
1036{
1037 if (actual < tag1 || actual > tag2)
1038 internal_error ("bytecode stream: tag %s is not in the expected range "
1039 "[%s, %s]",
1040 lto_tag_name (actual),
1041 lto_tag_name (tag1),
1042 lto_tag_name (tag2));
1043}
1044
1045/* Initialize an lto_out_decl_buffer ENCODER. */
1046static inline void
1047lto_init_tree_ref_encoder (struct lto_tree_ref_encoder *encoder)
1048{
1049 encoder->tree_hash_table = new hash_map<tree, unsigned> (251);
1050 encoder->trees.create (0);
1051}
1052
1053
1054/* Destroy an lto_tree_ref_encoder ENCODER by freeing its contents. The
1055 memory used by ENCODER is not freed by this function. */
1056static inline void
1057lto_destroy_tree_ref_encoder (struct lto_tree_ref_encoder *encoder)
1058{
1059 /* Hash table may be delete already. */
1060 delete encoder->tree_hash_table;
1061 encoder->tree_hash_table = NULL;
1062 encoder->trees.release ();
1063}
1064
1065/* Return the number of trees encoded in ENCODER. */
1066static inline unsigned int
1067lto_tree_ref_encoder_size (struct lto_tree_ref_encoder *encoder)
1068{
1069 return encoder->trees.length ();
1070}
1071
1072/* Return the IDX-th tree in ENCODER. */
1073static inline tree
1074lto_tree_ref_encoder_get_tree (struct lto_tree_ref_encoder *encoder,
1075 unsigned int idx)
1076{
1077 return encoder->trees[idx];
1078}
1079
1080/* Return number of encoded nodes in ENCODER. */
1081static inline int
1082lto_symtab_encoder_size (lto_symtab_encoder_t encoder)
1083{
1084 return encoder->nodes.length ();
1085}
1086
1087/* Value used to represent failure of lto_symtab_encoder_lookup. */
1088#define LCC_NOT_FOUND (-1)
1089
1090/* Look up NODE in encoder. Return NODE's reference if it has been encoded
1091 or LCC_NOT_FOUND if it is not there. */
1092
1093static inline int
1094lto_symtab_encoder_lookup (lto_symtab_encoder_t encoder,
1095 symtab_node *node)
1096{
1097 size_t *slot = encoder->map->get (node);
1098 return (slot && *slot ? *(slot) - 1 : LCC_NOT_FOUND);
1099}
1100
1101/* Return true if iterator LSE points to nothing. */
1102static inline bool
1103lsei_end_p (lto_symtab_encoder_iterator lsei)
1104{
1105 return lsei.index >= (unsigned)lto_symtab_encoder_size (lsei.encoder);
1106}
1107
1108/* Advance iterator LSE. */
1109static inline void
1110lsei_next (lto_symtab_encoder_iterator *lsei)
1111{
1112 lsei->index++;
1113}
1114
1115/* Return the node pointed to by LSI. */
1116static inline symtab_node *
1117lsei_node (lto_symtab_encoder_iterator lsei)
1118{
1119 return lsei.encoder->nodes[lsei.index].node;
1120}
1121
1122/* Return the node pointed to by LSI. */
1123static inline struct cgraph_node *
1124lsei_cgraph_node (lto_symtab_encoder_iterator lsei)
1125{
1126 return dyn_cast<cgraph_node *> (lsei.encoder->nodes[lsei.index].node);
1127}
1128
1129/* Return the node pointed to by LSI. */
1130static inline varpool_node *
1131lsei_varpool_node (lto_symtab_encoder_iterator lsei)
1132{
1133 return dyn_cast<varpool_node *> (lsei.encoder->nodes[lsei.index].node);
1134}
1135
1136/* Return the cgraph node corresponding to REF using ENCODER. */
1137
1138static inline symtab_node *
1139lto_symtab_encoder_deref (lto_symtab_encoder_t encoder, int ref)
1140{
1141 if (ref == LCC_NOT_FOUND)
1142 return NULL;
1143
1144 return encoder->nodes[ref].node;
1145}
1146
1147/* Return an iterator to the first node in LSI. */
1148static inline lto_symtab_encoder_iterator
1149lsei_start (lto_symtab_encoder_t encoder)
1150{
1151 lto_symtab_encoder_iterator lsei;
1152
1153 lsei.encoder = encoder;
1154 lsei.index = 0;
1155 return lsei;
1156}
1157
1158/* Advance iterator LSE. */
1159static inline void
1160lsei_next_in_partition (lto_symtab_encoder_iterator *lsei)
1161{
1162 lsei_next (lsei);
1163 while (!lsei_end_p (*lsei)
1164 && !lto_symtab_encoder_in_partition_p (lsei->encoder, lsei_node (*lsei)))
1165 lsei_next (lsei);
1166}
1167
1168/* Return an iterator to the first node in LSI. */
1169static inline lto_symtab_encoder_iterator
1170lsei_start_in_partition (lto_symtab_encoder_t encoder)
1171{
1172 lto_symtab_encoder_iterator lsei = lsei_start (encoder);
1173
1174 if (lsei_end_p (lsei))
1175 return lsei;
1176 if (!lto_symtab_encoder_in_partition_p (encoder, lsei_node (lsei)))
1177 lsei_next_in_partition (&lsei);
1178
1179 return lsei;
1180}
1181
1182/* Advance iterator LSE. */
1183static inline void
1184lsei_next_function_in_partition (lto_symtab_encoder_iterator *lsei)
1185{
1186 lsei_next (lsei);
1187 while (!lsei_end_p (*lsei)
1188 && (!is_a <cgraph_node *> (lsei_node (*lsei))
1189 || !lto_symtab_encoder_in_partition_p (lsei->encoder, lsei_node (*lsei))))
1190 lsei_next (lsei);
1191}
1192
1193/* Return an iterator to the first node in LSI. */
1194static inline lto_symtab_encoder_iterator
1195lsei_start_function_in_partition (lto_symtab_encoder_t encoder)
1196{
1197 lto_symtab_encoder_iterator lsei = lsei_start (encoder);
1198
1199 if (lsei_end_p (lsei))
1200 return lsei;
1201 if (!is_a <cgraph_node *> (lsei_node (lsei))
1202 || !lto_symtab_encoder_in_partition_p (encoder, lsei_node (lsei)))
1203 lsei_next_function_in_partition (&lsei);
1204
1205 return lsei;
1206}
1207
1208/* Advance iterator LSE. */
1209static inline void
1210lsei_next_variable_in_partition (lto_symtab_encoder_iterator *lsei)
1211{
1212 lsei_next (lsei);
1213 while (!lsei_end_p (*lsei)
1214 && (!is_a <varpool_node *> (lsei_node (*lsei))
1215 || !lto_symtab_encoder_in_partition_p (lsei->encoder, lsei_node (*lsei))))
1216 lsei_next (lsei);
1217}
1218
1219/* Return an iterator to the first node in LSI. */
1220static inline lto_symtab_encoder_iterator
1221lsei_start_variable_in_partition (lto_symtab_encoder_t encoder)
1222{
1223 lto_symtab_encoder_iterator lsei = lsei_start (encoder);
1224
1225 if (lsei_end_p (lsei))
1226 return lsei;
1227 if (!is_a <varpool_node *> (lsei_node (lsei))
1228 || !lto_symtab_encoder_in_partition_p (encoder, lsei_node (lsei)))
1229 lsei_next_variable_in_partition (&lsei);
1230
1231 return lsei;
1232}
1233
1234/* Entry for the delayed registering of decl -> DIE references. */
1235struct dref_entry {
1236 tree decl;
1237 const char *sym;
1238 unsigned HOST_WIDE_INT off;
1239};
1240
1241extern vec<dref_entry> dref_queue;
1242
1243extern FILE *streamer_dump_file;
1244
1245#endif /* GCC_LTO_STREAMER_H */
1246

source code of gcc/lto-streamer.h