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