1/* Data structures and declarations used for reading and writing
2 GIMPLE to a file stream.
3
4 Copyright (C) 2009-2023 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 unsigned discr;
315 };
316
317 /* The location cache. */
318
319 auto_vec<cached_location> loc_cache;
320
321 /* Accepted entries are ones used by trees that are known to be not unified
322 by tree merging. */
323
324 int accepted_length;
325
326 /* Bookkeeping to remember state in between calls to lto_apply_location_cache
327 When streaming gimple, the location cache is not used and thus
328 lto_apply_location_cache happens per location basis. It is then
329 useful to avoid redundant calls of linemap API. */
330
331 const char *current_file;
332 int current_line;
333 int current_col;
334 bool current_sysp;
335 location_t current_loc;
336 tree current_block;
337 unsigned current_discr;
338};
339
340/* Structure used as buffer for reading an LTO file. */
341class lto_input_block
342{
343public:
344 /* Special constructor for the string table, it abuses this to
345 do random access but use the uhwi decoder. */
346 lto_input_block (const char *data_, unsigned int p_, unsigned int len_,
347 const lto_file_decl_data *file_data_)
348 : data (data_), file_data (file_data_), p (p_), len (len_) {}
349 lto_input_block (const char *data_, unsigned int len_,
350 const lto_file_decl_data *file_data_)
351 : data (data_), file_data (file_data_), p (0), len (len_) {}
352
353 const char *data;
354 const lto_file_decl_data *file_data;
355 unsigned int p;
356 unsigned int len;
357};
358
359/* Compression algorithm used for compression of LTO bytecode. */
360
361enum lto_compression
362{
363 ZLIB,
364 ZSTD
365};
366
367/* Structure that represents LTO ELF section with information
368 about the format. */
369
370struct lto_section
371{
372 int16_t major_version;
373 int16_t minor_version;
374 unsigned char slim_object;
375 unsigned char _padding;
376
377 /* Flags is a private field that is not defined publicly. */
378 uint16_t flags;
379
380 /* Set compression to FLAGS. */
381 inline void set_compression (lto_compression c)
382 {
383 flags = c;
384 }
385
386 /* Get compression from FLAGS. */
387 inline lto_compression get_compression ()
388 {
389 return (lto_compression) flags;
390 }
391};
392
393STATIC_ASSERT (sizeof (lto_section) == 8);
394
395/* The is the first part of the record in an LTO file for many of the
396 IPA passes. */
397struct lto_simple_header
398{
399 /* Size of main gimple body of function. */
400 int32_t main_size;
401};
402
403struct lto_simple_header_with_strings : lto_simple_header
404{
405 /* Size of the string table. */
406 int32_t string_size;
407};
408
409/* The header for a function body. */
410struct lto_function_header : lto_simple_header_with_strings
411{
412 /* Size of the cfg. */
413 int32_t cfg_size;
414};
415
416
417/* Structure describing a symbol section. */
418struct lto_decl_header : lto_simple_header_with_strings
419{
420 /* Size of region for decl state. */
421 int32_t decl_state_size;
422
423 /* Number of nodes in globals stream. */
424 int32_t num_nodes;
425};
426
427
428/* Statistics gathered during LTO, WPA and LTRANS. */
429struct lto_stats_d
430{
431 unsigned HOST_WIDE_INT num_input_cgraph_nodes;
432 unsigned HOST_WIDE_INT num_output_symtab_nodes;
433 unsigned HOST_WIDE_INT num_input_files;
434 unsigned HOST_WIDE_INT num_output_files;
435 unsigned HOST_WIDE_INT num_cgraph_partitions;
436 unsigned HOST_WIDE_INT section_size[LTO_N_SECTION_TYPES];
437 unsigned HOST_WIDE_INT num_function_bodies;
438 unsigned HOST_WIDE_INT num_trees[NUM_TREE_CODES];
439 unsigned HOST_WIDE_INT num_output_il_bytes;
440 unsigned HOST_WIDE_INT num_compressed_il_bytes;
441 unsigned HOST_WIDE_INT num_input_il_bytes;
442 unsigned HOST_WIDE_INT num_uncompressed_il_bytes;
443 unsigned HOST_WIDE_INT num_tree_bodies_output;
444 unsigned HOST_WIDE_INT num_pickle_refs_output;
445};
446
447/* Entry of LTO symtab encoder. */
448struct lto_encoder_entry
449{
450 symtab_node *node;
451 /* Is the node in this partition (i.e. ltrans of this partition will
452 be responsible for outputting it)? */
453 unsigned int in_partition:1;
454 /* Do we encode body in this partition? */
455 unsigned int body:1;
456 /* Do we encode initializer in this partition?
457 For example the readonly variable initializers are encoded to aid
458 constant folding even if they are not in the partition. */
459 unsigned int initializer:1;
460};
461
462
463/* Encoder data structure used to stream callgraph nodes. */
464struct lto_symtab_encoder_d
465{
466 vec<lto_encoder_entry> nodes;
467 hash_map<symtab_node *, size_t> *map;
468};
469
470typedef struct lto_symtab_encoder_d *lto_symtab_encoder_t;
471
472/* Iterator structure for cgraph node sets. */
473struct lto_symtab_encoder_iterator
474{
475 lto_symtab_encoder_t encoder;
476 unsigned index;
477};
478
479
480
481/* The lto_tree_ref_encoder struct is used to encode trees into indices. */
482
483struct lto_tree_ref_encoder
484{
485 hash_map<tree, unsigned> *tree_hash_table; /* Maps pointers to indices. */
486 vec<tree> trees; /* Maps indices to pointers. */
487};
488
489
490/* Structure to hold states of input scope. */
491struct GTY((for_user)) lto_in_decl_state
492{
493 /* Array of lto_in_decl_buffers to store type and decls streams. */
494 vec<tree, va_gc> *streams[LTO_N_DECL_STREAMS];
495
496 /* If this in-decl state is associated with a function. FN_DECL
497 point to the FUNCTION_DECL. */
498 tree fn_decl;
499
500 /* True if decl state is compressed. */
501 bool compressed;
502};
503
504typedef struct lto_in_decl_state *lto_in_decl_state_ptr;
505
506struct decl_state_hasher : ggc_ptr_hash<lto_in_decl_state>
507{
508 static hashval_t
509 hash (lto_in_decl_state *s)
510 {
511 return htab_hash_pointer (s->fn_decl);
512 }
513
514 static bool
515 equal (lto_in_decl_state *a, lto_in_decl_state *b)
516 {
517 return a->fn_decl == b->fn_decl;
518 }
519};
520
521/* The structure that holds all of the vectors of global types,
522 decls and cgraph nodes used in the serialization of this file. */
523struct lto_out_decl_state
524{
525 /* The buffers contain the sets of decls of various kinds and types we have
526 seen so far and the indexes assigned to them. */
527 struct lto_tree_ref_encoder streams[LTO_N_DECL_STREAMS];
528
529 /* Encoder for cgraph nodes. */
530 lto_symtab_encoder_t symtab_node_encoder;
531
532 /* If this out-decl state belongs to a function, fn_decl points to that
533 function. Otherwise, it is NULL. */
534 tree fn_decl;
535
536 /* True if decl state is compressed. */
537 bool compressed;
538};
539
540typedef struct lto_out_decl_state *lto_out_decl_state_ptr;
541
542
543/* Compact representation of a index <-> resolution pair. Unpacked to an
544 vector later. */
545struct res_pair
546{
547 ld_plugin_symbol_resolution_t res;
548 unsigned index;
549};
550
551
552/* One of these is allocated for each object file that being compiled
553 by lto. This structure contains the tables that are needed by the
554 serialized functions and ipa passes to connect themselves to the
555 global types and decls as they are reconstituted. */
556struct GTY(()) lto_file_decl_data
557{
558 /* Decl state currently used. */
559 struct lto_in_decl_state *current_decl_state;
560
561 /* Decl state corresponding to regions outside of any functions
562 in the compilation unit. */
563 struct lto_in_decl_state *global_decl_state;
564
565 /* Table of cgraph nodes present in this file. */
566 lto_symtab_encoder_t GTY((skip)) symtab_node_encoder;
567
568 /* Hash table maps lto-related section names to location in file. */
569 hash_table<decl_state_hasher> *function_decl_states;
570
571 /* The .o file that these offsets relate to. */
572 const char *GTY((skip)) file_name;
573
574 /* Hash table maps lto-related section names to location in file. */
575 htab_t GTY((skip)) section_hash_table;
576
577 /* Hash new name of renamed global declaration to its original name. */
578 htab_t GTY((skip)) renaming_hash_table;
579
580 /* Linked list used temporarily in reader */
581 struct lto_file_decl_data *next;
582
583 /* Order in which the file appears on the command line. */
584 int order;
585
586 /* Sub ID for merged objects. */
587 unsigned HOST_WIDE_INT id;
588
589 /* Symbol resolutions for this file */
590 vec<res_pair> GTY((skip)) respairs;
591 unsigned max_index;
592
593 gcov_summary GTY((skip)) profile_info;
594
595 /* Map assigning declarations their resolutions. */
596 hash_map<tree, ld_plugin_symbol_resolution> * GTY((skip)) resolution_map;
597
598 /* Mode translation table. */
599 const unsigned char *mode_table;
600
601 /* Read LTO section. */
602 lto_section lto_section_header;
603
604 int order_base;
605
606 int unit_base;
607
608 unsigned mode_bits;
609};
610
611typedef struct lto_file_decl_data *lto_file_decl_data_ptr;
612
613struct lto_char_ptr_base
614{
615 char *ptr;
616};
617
618/* An incore byte stream to buffer the various parts of the function.
619 The entire structure should be zeroed when created. The record
620 consists of a set of blocks. The first sizeof (ptr) bytes are used
621 as a chain, and the rest store the bytes to be written. */
622struct lto_output_stream
623{
624 /* The pointer to the first block in the stream. */
625 struct lto_char_ptr_base * first_block;
626
627 /* The pointer to the last and current block in the stream. */
628 struct lto_char_ptr_base * current_block;
629
630 /* The pointer to where the next char should be written. */
631 char * current_pointer;
632
633 /* The number of characters left in the current block. */
634 unsigned int left_in_block;
635
636 /* The block size of the last block allocated. */
637 unsigned int block_size;
638
639 /* The total number of characters written. */
640 unsigned int total_size;
641};
642
643/* A simple output block. This can be used for simple IPA passes that
644 do not need more than one stream. */
645struct lto_simple_output_block
646{
647 enum lto_section_type section_type;
648 struct lto_out_decl_state *decl_state;
649
650 /* The stream that the main tree codes are written to. */
651 struct lto_output_stream *main_stream;
652};
653
654/* String hashing. */
655
656struct string_slot
657{
658 const char *s;
659 int len;
660 unsigned int slot_num;
661};
662
663/* Hashtable helpers. */
664
665struct string_slot_hasher : nofree_ptr_hash <string_slot>
666{
667 static inline hashval_t hash (const string_slot *);
668 static inline bool equal (const string_slot *, const string_slot *);
669};
670
671/* Returns a hash code for DS. Adapted from libiberty's htab_hash_string
672 to support strings that may not end in '\0'. */
673
674inline hashval_t
675string_slot_hasher::hash (const string_slot *ds)
676{
677 hashval_t r = ds->len;
678 int i;
679
680 for (i = 0; i < ds->len; i++)
681 r = r * 67 + (unsigned)ds->s[i] - 113;
682 return r;
683}
684
685/* Returns nonzero if DS1 and DS2 are equal. */
686
687inline bool
688string_slot_hasher::equal (const string_slot *ds1, const string_slot *ds2)
689{
690 if (ds1->len == ds2->len)
691 return memcmp (s1: ds1->s, s2: ds2->s, n: ds1->len) == 0;
692
693 return 0;
694}
695
696/* Data structure holding all the data and descriptors used when writing
697 an LTO file. */
698struct output_block
699{
700 enum lto_section_type section_type;
701 struct lto_out_decl_state *decl_state;
702
703 /* The stream that the main tree codes are written to. */
704 struct lto_output_stream *main_stream;
705
706 /* The stream that contains the string table. */
707 struct lto_output_stream *string_stream;
708
709 /* The stream that contains the cfg. */
710 struct lto_output_stream *cfg_stream;
711
712 /* The hash table that contains the set of strings we have seen so
713 far and the indexes assigned to them. */
714 hash_table<string_slot_hasher> *string_hash_table;
715
716 /* The current symbol that we are currently serializing. Null
717 if we are serializing something else. */
718 symtab_node *symbol;
719
720 /* These are the last file and line that were seen in the stream.
721 If the current node differs from these, it needs to insert
722 something into the stream and fix these up. */
723 const char *current_file;
724 int current_line;
725 int current_col;
726 bool current_sysp;
727 bool reset_locus;
728 bool emit_pwd;
729 tree current_block;
730 unsigned current_discr;
731
732 /* Cache of nodes written in this section. */
733 struct streamer_tree_cache_d *writer_cache;
734
735 /* All trees identified as local to the unit streamed. */
736 hash_set<tree> *local_trees;
737
738 /* All data persistent across whole duration of output block
739 can go here. */
740 struct obstack obstack;
741};
742
743
744/* Data and descriptors used when reading from an LTO file. */
745class data_in
746{
747public:
748 /* The global decls and types. */
749 struct lto_file_decl_data *file_data;
750
751 /* The string table. */
752 const char *strings;
753
754 /* The length of the string table. */
755 unsigned int strings_len;
756
757 /* Maps each reference number to the resolution done by the linker. */
758 vec<ld_plugin_symbol_resolution_t> globals_resolution;
759
760 /* Cache of pickled nodes. */
761 struct streamer_tree_cache_d *reader_cache;
762
763 /* Cache of source code location. */
764 lto_location_cache location_cache;
765};
766
767
768/* In lto-section-in.cc */
769extern class lto_input_block * lto_create_simple_input_block (
770 struct lto_file_decl_data *,
771 enum lto_section_type, const char **, size_t *);
772extern void
773lto_destroy_simple_input_block (struct lto_file_decl_data *,
774 enum lto_section_type,
775 class lto_input_block *, const char *, size_t);
776extern void lto_set_in_hooks (struct lto_file_decl_data **,
777 lto_get_section_data_f *,
778 lto_free_section_data_f *);
779extern struct lto_file_decl_data **lto_get_file_decl_data (void);
780extern const char *lto_get_section_data (struct lto_file_decl_data *,
781 enum lto_section_type,
782 const char *, int, size_t *,
783 bool decompress = false);
784extern const char *lto_get_summary_section_data (struct lto_file_decl_data *,
785 enum lto_section_type,
786 size_t *);
787extern const char *lto_get_raw_section_data (struct lto_file_decl_data *,
788 enum lto_section_type,
789 const char *, int, size_t *);
790extern void lto_free_section_data (struct lto_file_decl_data *,
791 enum lto_section_type,
792 const char *, const char *, size_t,
793 bool decompress = false);
794extern void lto_free_raw_section_data (struct lto_file_decl_data *,
795 enum lto_section_type,
796 const char *, const char *, size_t);
797extern htab_t lto_create_renaming_table (void);
798extern void lto_record_renamed_decl (struct lto_file_decl_data *,
799 const char *, const char *);
800extern const char *lto_get_decl_name_mapping (struct lto_file_decl_data *,
801 const char *);
802extern struct lto_in_decl_state *lto_new_in_decl_state (void);
803extern void lto_delete_in_decl_state (struct lto_in_decl_state *);
804extern struct lto_in_decl_state *lto_get_function_in_decl_state (
805 struct lto_file_decl_data *, tree);
806extern void lto_free_function_in_decl_state (struct lto_in_decl_state *);
807extern void lto_free_function_in_decl_state_for_node (symtab_node *);
808extern void lto_section_overrun (class lto_input_block *) ATTRIBUTE_NORETURN;
809extern void lto_value_range_error (const char *,
810 HOST_WIDE_INT, HOST_WIDE_INT,
811 HOST_WIDE_INT) ATTRIBUTE_NORETURN;
812
813/* In lto-section-out.cc */
814extern void lto_begin_section (const char *, bool);
815extern void lto_end_section (void);
816extern void lto_write_data (const void *, unsigned int);
817extern void lto_write_raw_data (const void *, unsigned int);
818extern void lto_write_stream (struct lto_output_stream *);
819extern struct lto_simple_output_block *lto_create_simple_output_block (
820 enum lto_section_type);
821extern void lto_destroy_simple_output_block (struct lto_simple_output_block *);
822extern struct lto_out_decl_state *lto_new_out_decl_state (void);
823extern void lto_delete_out_decl_state (struct lto_out_decl_state *);
824extern struct lto_out_decl_state *lto_get_out_decl_state (void);
825extern void lto_push_out_decl_state (struct lto_out_decl_state *);
826extern struct lto_out_decl_state *lto_pop_out_decl_state (void);
827extern void lto_record_function_out_decl_state (tree,
828 struct lto_out_decl_state *);
829extern void lto_append_block (struct lto_output_stream *);
830
831
832/* In lto-streamer.cc. */
833
834/* Set when streaming LTO for offloading compiler. */
835extern bool lto_stream_offload_p;
836
837extern const char *lto_tag_name (enum LTO_tags);
838extern char *lto_get_section_name (int, const char *, int,
839 struct lto_file_decl_data *);
840extern void print_lto_report (const char *);
841extern void lto_streamer_init (void);
842extern bool gate_lto_out (void);
843extern void lto_check_version (int, int, const char *);
844extern void lto_streamer_hooks_init (void);
845
846/* In lto-streamer-in.cc */
847extern void lto_input_cgraph (struct lto_file_decl_data *, const char *);
848extern void lto_reader_init (void);
849extern void lto_free_file_name_hash (void);
850extern void lto_input_function_body (struct lto_file_decl_data *,
851 struct cgraph_node *,
852 const char *);
853extern void lto_input_variable_constructor (struct lto_file_decl_data *,
854 struct varpool_node *,
855 const char *);
856extern void lto_input_constructors_and_inits (struct lto_file_decl_data *,
857 const char *);
858extern void lto_input_toplevel_asms (struct lto_file_decl_data *, int);
859extern void lto_input_mode_table (struct lto_file_decl_data *);
860extern class data_in *lto_data_in_create (struct lto_file_decl_data *,
861 const char *, unsigned,
862 vec<ld_plugin_symbol_resolution_t> );
863extern void lto_data_in_delete (class data_in *);
864extern void lto_input_data_block (class lto_input_block *, void *, size_t);
865void lto_input_location (location_t *, struct bitpack_d *, class data_in *);
866tree lto_input_tree_ref (class lto_input_block *, class data_in *,
867 struct function *, enum LTO_tags);
868void lto_tag_check_set (enum LTO_tags, int, ...);
869void lto_init_eh (void);
870hashval_t lto_input_scc (class lto_input_block *, class data_in *,
871 unsigned *, unsigned *, bool);
872tree lto_input_tree_1 (class lto_input_block *, class data_in *,
873 enum LTO_tags, hashval_t hash);
874tree lto_input_tree (class lto_input_block *, class data_in *);
875tree stream_read_tree_ref (class lto_input_block *, class data_in *);
876
877
878/* In lto-streamer-out.cc */
879extern void lto_register_decl_definition (tree, struct lto_file_decl_data *);
880extern struct output_block *create_output_block (enum lto_section_type);
881extern void destroy_output_block (struct output_block *);
882extern void lto_output_tree (struct output_block *, tree, bool, bool);
883extern void stream_write_tree_ref (struct output_block *, tree);
884extern void lto_output_var_decl_ref (struct lto_out_decl_state *,
885 struct lto_output_stream *, tree);
886extern void lto_output_fn_decl_ref (struct lto_out_decl_state *,
887 struct lto_output_stream *, tree);
888extern tree lto_input_var_decl_ref (lto_input_block *, lto_file_decl_data *);
889extern tree lto_input_fn_decl_ref (lto_input_block *, lto_file_decl_data *);
890extern void lto_output_toplevel_asms (void);
891extern void produce_asm (struct output_block *ob, tree fn);
892extern void lto_output ();
893extern void produce_asm_for_decls ();
894void lto_output_decl_state_streams (struct output_block *,
895 struct lto_out_decl_state *);
896void lto_output_decl_state_refs (struct output_block *,
897 struct lto_output_stream *,
898 struct lto_out_decl_state *);
899void lto_output_location (struct output_block *, struct bitpack_d *,
900 location_t);
901void lto_output_location_and_block (struct output_block *, struct bitpack_d *,
902 location_t);
903void lto_output_init_mode_table (void);
904void lto_prepare_function_for_streaming (cgraph_node *);
905
906
907/* In lto-cgraph.cc */
908extern bool asm_nodes_output;
909lto_symtab_encoder_t lto_symtab_encoder_new (bool);
910int lto_symtab_encoder_encode (lto_symtab_encoder_t, symtab_node *);
911void lto_symtab_encoder_delete (lto_symtab_encoder_t);
912bool lto_symtab_encoder_delete_node (lto_symtab_encoder_t, symtab_node *);
913bool lto_symtab_encoder_encode_body_p (lto_symtab_encoder_t,
914 struct cgraph_node *);
915bool lto_symtab_encoder_in_partition_p (lto_symtab_encoder_t,
916 symtab_node *);
917void lto_set_symtab_encoder_in_partition (lto_symtab_encoder_t,
918 symtab_node *);
919
920bool lto_symtab_encoder_encode_initializer_p (lto_symtab_encoder_t,
921 varpool_node *);
922void output_symtab (void);
923void input_symtab (void);
924void output_offload_tables (void);
925void input_offload_tables (bool);
926bool referenced_from_other_partition_p (struct ipa_ref_list *,
927 lto_symtab_encoder_t);
928bool reachable_from_other_partition_p (struct cgraph_node *,
929 lto_symtab_encoder_t);
930bool referenced_from_this_partition_p (symtab_node *,
931 lto_symtab_encoder_t);
932bool reachable_from_this_partition_p (struct cgraph_node *,
933 lto_symtab_encoder_t);
934lto_symtab_encoder_t compute_ltrans_boundary (lto_symtab_encoder_t encoder);
935void select_what_to_stream (void);
936
937/* In omp-general.cc. */
938void omp_lto_output_declare_variant_alt (lto_simple_output_block *,
939 cgraph_node *, lto_symtab_encoder_t);
940void omp_lto_input_declare_variant_alt (lto_input_block *, cgraph_node *,
941 vec<symtab_node *>);
942
943/* In options-save.cc. */
944void cl_target_option_stream_out (struct output_block *, struct bitpack_d *,
945 struct cl_target_option *);
946
947void cl_target_option_stream_in (class data_in *,
948 struct bitpack_d *,
949 struct cl_target_option *);
950
951void cl_optimization_stream_out (struct output_block *,
952 struct bitpack_d *, struct cl_optimization *);
953
954void cl_optimization_stream_in (class data_in *,
955 struct bitpack_d *, struct cl_optimization *);
956
957
958
959/* In lto-opts.cc. */
960extern void lto_write_options (void);
961
962
963/* Statistics gathered during LTO, WPA and LTRANS. */
964extern struct lto_stats_d lto_stats;
965
966/* Section names corresponding to the values of enum lto_section_type. */
967extern const char *lto_section_name[];
968
969/* Holds all the out decl states of functions output so far in the
970 current output file. */
971extern vec<lto_out_decl_state_ptr> lto_function_decl_states;
972
973/* Return true if LTO tag TAG corresponds to a tree code. */
974inline bool
975lto_tag_is_tree_code_p (enum LTO_tags tag)
976{
977 return tag > LTO_first_tree_tag && (unsigned) tag <= MAX_TREE_CODES;
978}
979
980
981/* Return true if LTO tag TAG corresponds to a gimple code. */
982inline bool
983lto_tag_is_gimple_code_p (enum LTO_tags tag)
984{
985 return (unsigned) tag >= LTO_first_gimple_tag
986 && (unsigned) tag
987 < LTO_first_gimple_tag + LAST_AND_UNUSED_GIMPLE_CODE;
988}
989
990
991/* Return the LTO tag corresponding to gimple code CODE. See enum
992 LTO_tags for details on the conversion. */
993inline enum LTO_tags
994lto_gimple_code_to_tag (enum gimple_code code)
995{
996 return (enum LTO_tags) ((unsigned) code + LTO_first_gimple_tag);
997}
998
999
1000/* Return the GIMPLE code corresponding to TAG. See enum LTO_tags for
1001 details on the conversion. */
1002inline enum gimple_code
1003lto_tag_to_gimple_code (enum LTO_tags tag)
1004{
1005 gcc_assert (lto_tag_is_gimple_code_p (tag));
1006 return (enum gimple_code) ((unsigned) tag - LTO_first_gimple_tag);
1007}
1008
1009
1010/* Return the LTO tag corresponding to tree code CODE. See enum
1011 LTO_tags for details on the conversion. */
1012inline enum LTO_tags
1013lto_tree_code_to_tag (enum tree_code code)
1014{
1015 return (enum LTO_tags) ((unsigned) code + LTO_first_tree_tag);
1016}
1017
1018
1019/* Return the tree code corresponding to TAG. See enum LTO_tags for
1020 details on the conversion. */
1021inline enum tree_code
1022lto_tag_to_tree_code (enum LTO_tags tag)
1023{
1024 gcc_assert (lto_tag_is_tree_code_p (tag));
1025 return (enum tree_code) ((unsigned) tag - LTO_first_tree_tag);
1026}
1027
1028/* Check that tag ACTUAL == EXPECTED. */
1029inline void
1030lto_tag_check (enum LTO_tags actual, enum LTO_tags expected)
1031{
1032 if (actual != expected)
1033 internal_error ("bytecode stream: expected tag %s instead of %s",
1034 lto_tag_name (expected), lto_tag_name (actual));
1035}
1036
1037/* Check that tag ACTUAL is in the range [TAG1, TAG2]. */
1038inline void
1039lto_tag_check_range (enum LTO_tags actual, enum LTO_tags tag1,
1040 enum LTO_tags tag2)
1041{
1042 if (actual < tag1 || actual > tag2)
1043 internal_error ("bytecode stream: tag %s is not in the expected range "
1044 "[%s, %s]",
1045 lto_tag_name (actual),
1046 lto_tag_name (tag1),
1047 lto_tag_name (tag2));
1048}
1049
1050/* Initialize an lto_out_decl_buffer ENCODER. */
1051inline void
1052lto_init_tree_ref_encoder (struct lto_tree_ref_encoder *encoder)
1053{
1054 encoder->tree_hash_table = new hash_map<tree, unsigned> (251);
1055 encoder->trees.create (nelems: 0);
1056}
1057
1058
1059/* Destroy an lto_tree_ref_encoder ENCODER by freeing its contents. The
1060 memory used by ENCODER is not freed by this function. */
1061inline void
1062lto_destroy_tree_ref_encoder (struct lto_tree_ref_encoder *encoder)
1063{
1064 /* Hash table may be delete already. */
1065 delete encoder->tree_hash_table;
1066 encoder->tree_hash_table = NULL;
1067 encoder->trees.release ();
1068}
1069
1070/* Return the number of trees encoded in ENCODER. */
1071inline unsigned int
1072lto_tree_ref_encoder_size (struct lto_tree_ref_encoder *encoder)
1073{
1074 return encoder->trees.length ();
1075}
1076
1077/* Return the IDX-th tree in ENCODER. */
1078inline tree
1079lto_tree_ref_encoder_get_tree (struct lto_tree_ref_encoder *encoder,
1080 unsigned int idx)
1081{
1082 return encoder->trees[idx];
1083}
1084
1085/* Return number of encoded nodes in ENCODER. */
1086inline int
1087lto_symtab_encoder_size (lto_symtab_encoder_t encoder)
1088{
1089 return encoder->nodes.length ();
1090}
1091
1092/* Value used to represent failure of lto_symtab_encoder_lookup. */
1093#define LCC_NOT_FOUND (-1)
1094
1095/* Look up NODE in encoder. Return NODE's reference if it has been encoded
1096 or LCC_NOT_FOUND if it is not there. */
1097
1098inline int
1099lto_symtab_encoder_lookup (lto_symtab_encoder_t encoder,
1100 symtab_node *node)
1101{
1102 size_t *slot = encoder->map->get (k: node);
1103 return (slot && *slot ? *(slot) - 1 : LCC_NOT_FOUND);
1104}
1105
1106/* Return true if iterator LSE points to nothing. */
1107inline bool
1108lsei_end_p (lto_symtab_encoder_iterator lsei)
1109{
1110 return lsei.index >= (unsigned)lto_symtab_encoder_size (encoder: lsei.encoder);
1111}
1112
1113/* Advance iterator LSE. */
1114inline void
1115lsei_next (lto_symtab_encoder_iterator *lsei)
1116{
1117 lsei->index++;
1118}
1119
1120/* Return the node pointed to by LSI. */
1121inline symtab_node *
1122lsei_node (lto_symtab_encoder_iterator lsei)
1123{
1124 return lsei.encoder->nodes[lsei.index].node;
1125}
1126
1127/* Return the node pointed to by LSI. */
1128inline struct cgraph_node *
1129lsei_cgraph_node (lto_symtab_encoder_iterator lsei)
1130{
1131 return dyn_cast<cgraph_node *> (p: lsei.encoder->nodes[lsei.index].node);
1132}
1133
1134/* Return the node pointed to by LSI. */
1135inline varpool_node *
1136lsei_varpool_node (lto_symtab_encoder_iterator lsei)
1137{
1138 return dyn_cast<varpool_node *> (p: lsei.encoder->nodes[lsei.index].node);
1139}
1140
1141/* Return the cgraph node corresponding to REF using ENCODER. */
1142
1143inline symtab_node *
1144lto_symtab_encoder_deref (lto_symtab_encoder_t encoder, int ref)
1145{
1146 if (ref == LCC_NOT_FOUND)
1147 return NULL;
1148
1149 return encoder->nodes[ref].node;
1150}
1151
1152/* Return an iterator to the first node in LSI. */
1153inline lto_symtab_encoder_iterator
1154lsei_start (lto_symtab_encoder_t encoder)
1155{
1156 lto_symtab_encoder_iterator lsei;
1157
1158 lsei.encoder = encoder;
1159 lsei.index = 0;
1160 return lsei;
1161}
1162
1163/* Advance iterator LSE. */
1164inline void
1165lsei_next_in_partition (lto_symtab_encoder_iterator *lsei)
1166{
1167 lsei_next (lsei);
1168 while (!lsei_end_p (lsei: *lsei)
1169 && !lto_symtab_encoder_in_partition_p (lsei->encoder, lsei_node (lsei: *lsei)))
1170 lsei_next (lsei);
1171}
1172
1173/* Return an iterator to the first node in LSI. */
1174inline lto_symtab_encoder_iterator
1175lsei_start_in_partition (lto_symtab_encoder_t encoder)
1176{
1177 lto_symtab_encoder_iterator lsei = lsei_start (encoder);
1178
1179 if (lsei_end_p (lsei))
1180 return lsei;
1181 if (!lto_symtab_encoder_in_partition_p (encoder, lsei_node (lsei)))
1182 lsei_next_in_partition (lsei: &lsei);
1183
1184 return lsei;
1185}
1186
1187/* Advance iterator LSE. */
1188inline void
1189lsei_next_function_in_partition (lto_symtab_encoder_iterator *lsei)
1190{
1191 lsei_next (lsei);
1192 while (!lsei_end_p (lsei: *lsei)
1193 && (!is_a <cgraph_node *> (p: lsei_node (lsei: *lsei))
1194 || !lto_symtab_encoder_in_partition_p (lsei->encoder, lsei_node (lsei: *lsei))))
1195 lsei_next (lsei);
1196}
1197
1198/* Return an iterator to the first node in LSI. */
1199inline lto_symtab_encoder_iterator
1200lsei_start_function_in_partition (lto_symtab_encoder_t encoder)
1201{
1202 lto_symtab_encoder_iterator lsei = lsei_start (encoder);
1203
1204 if (lsei_end_p (lsei))
1205 return lsei;
1206 if (!is_a <cgraph_node *> (p: lsei_node (lsei))
1207 || !lto_symtab_encoder_in_partition_p (encoder, lsei_node (lsei)))
1208 lsei_next_function_in_partition (lsei: &lsei);
1209
1210 return lsei;
1211}
1212
1213/* Advance iterator LSE. */
1214inline void
1215lsei_next_variable_in_partition (lto_symtab_encoder_iterator *lsei)
1216{
1217 lsei_next (lsei);
1218 while (!lsei_end_p (lsei: *lsei)
1219 && (!is_a <varpool_node *> (p: lsei_node (lsei: *lsei))
1220 || !lto_symtab_encoder_in_partition_p (lsei->encoder, lsei_node (lsei: *lsei))))
1221 lsei_next (lsei);
1222}
1223
1224/* Return an iterator to the first node in LSI. */
1225inline lto_symtab_encoder_iterator
1226lsei_start_variable_in_partition (lto_symtab_encoder_t encoder)
1227{
1228 lto_symtab_encoder_iterator lsei = lsei_start (encoder);
1229
1230 if (lsei_end_p (lsei))
1231 return lsei;
1232 if (!is_a <varpool_node *> (p: lsei_node (lsei))
1233 || !lto_symtab_encoder_in_partition_p (encoder, lsei_node (lsei)))
1234 lsei_next_variable_in_partition (lsei: &lsei);
1235
1236 return lsei;
1237}
1238
1239/* Entry for the delayed registering of decl -> DIE references. */
1240struct dref_entry {
1241 tree decl;
1242 const char *sym;
1243 unsigned HOST_WIDE_INT off;
1244};
1245
1246extern vec<dref_entry> dref_queue;
1247
1248extern FILE *streamer_dump_file;
1249
1250#endif /* GCC_LTO_STREAMER_H */
1251

source code of gcc/lto-streamer.h