Branch data Line data Source code
1 : : /* Data structures and declarations used for reading and writing
2 : : GIMPLE to a file stream.
3 : :
4 : : Copyright (C) 2009-2024 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 : : #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 : :
127 : : typedef 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. */
131 : : static 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. */
137 : : enum 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. */
207 : : enum 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. */
236 : : enum lto_decl_stream_e_t
237 : : {
238 : : LTO_DECL_STREAM = 0, /* Must be first. */
239 : : LTO_N_DECL_STREAMS
240 : : };
241 : :
242 : : typedef 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. */
250 : : typedef 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. */
259 : : typedef 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 : :
269 : : class lto_location_cache
270 : : {
271 : : public:
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 : 201125 : lto_location_cache ()
285 : 201125 : : loc_cache (), accepted_length (0), current_file (NULL), current_line (0),
286 : 201125 : current_col (0), current_sysp (false), current_loc (UNKNOWN_LOCATION),
287 : 201125 : current_block (NULL_TREE)
288 : : {
289 : 201125 : gcc_assert (!current_cache);
290 : 201125 : current_cache = this;
291 : 201125 : }
292 : 201125 : ~lto_location_cache ()
293 : : {
294 : 201125 : apply_location_cache ();
295 : 201125 : gcc_assert (current_cache == this);
296 : 201125 : current_cache = NULL;
297 : 201125 : }
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 : :
304 : : private:
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. */
341 : : class lto_input_block
342 : : {
343 : : public:
344 : : /* Special constructor for the string table, it abuses this to
345 : : do random access but use the uhwi decoder. */
346 : 1269692 : lto_input_block (const char *data_, unsigned int p_, unsigned int len_,
347 : : const lto_file_decl_data *file_data_)
348 : 1269692 : : data (data_), file_data (file_data_), p (p_), len (len_) {}
349 : 348432 : lto_input_block (const char *data_, unsigned int len_,
350 : : const lto_file_decl_data *file_data_)
351 : 266477 : : 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 : :
361 : : enum lto_compression
362 : : {
363 : : ZLIB,
364 : : ZSTD
365 : : };
366 : :
367 : : /* Structure that represents LTO ELF section with information
368 : : about the format. */
369 : :
370 : : struct 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 : 32791 : inline void set_compression (lto_compression c)
382 : : {
383 : 32791 : flags = c;
384 : : }
385 : :
386 : : /* Get compression from FLAGS. */
387 : 206825 : inline lto_compression get_compression ()
388 : : {
389 : 206825 : return (lto_compression) flags;
390 : : }
391 : : };
392 : :
393 : : STATIC_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. */
397 : : struct lto_simple_header
398 : : {
399 : : /* Size of main gimple body of function. */
400 : : int32_t main_size;
401 : : };
402 : :
403 : : struct 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. */
410 : : struct 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. */
418 : : struct 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. */
429 : : struct 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. */
448 : : struct 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. */
464 : : struct lto_symtab_encoder_d
465 : : {
466 : : vec<lto_encoder_entry> nodes;
467 : : hash_map<symtab_node *, size_t> *map;
468 : : };
469 : :
470 : : typedef struct lto_symtab_encoder_d *lto_symtab_encoder_t;
471 : :
472 : : /* Iterator structure for cgraph node sets. */
473 : : struct 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 : :
483 : : struct 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. */
491 : : struct 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 : :
504 : : typedef struct lto_in_decl_state *lto_in_decl_state_ptr;
505 : :
506 : : struct decl_state_hasher : ggc_ptr_hash<lto_in_decl_state>
507 : : {
508 : : static hashval_t
509 : 1557060 : hash (lto_in_decl_state *s)
510 : : {
511 : 1557060 : return htab_hash_pointer (s->fn_decl);
512 : : }
513 : :
514 : : static bool
515 : 1384718 : equal (lto_in_decl_state *a, lto_in_decl_state *b)
516 : : {
517 : 1384718 : 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. */
523 : : struct 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 : :
540 : : typedef 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. */
545 : : struct 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. */
556 : : struct 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 : :
611 : : typedef struct lto_file_decl_data *lto_file_decl_data_ptr;
612 : :
613 : : struct 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. */
622 : : struct 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. */
645 : : struct 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 : :
656 : : struct string_slot
657 : : {
658 : : const char *s;
659 : : int len;
660 : : unsigned int slot_num;
661 : : };
662 : :
663 : : /* Hashtable helpers. */
664 : :
665 : : struct 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 : :
674 : : inline hashval_t
675 : 10759529 : string_slot_hasher::hash (const string_slot *ds)
676 : : {
677 : 10759529 : hashval_t r = ds->len;
678 : 10759529 : int i;
679 : :
680 : 268919181 : for (i = 0; i < ds->len; i++)
681 : 258159652 : r = r * 67 + (unsigned)ds->s[i] - 113;
682 : 10759529 : return r;
683 : : }
684 : :
685 : : /* Returns nonzero if DS1 and DS2 are equal. */
686 : :
687 : : inline bool
688 : 8527991 : string_slot_hasher::equal (const string_slot *ds1, const string_slot *ds2)
689 : : {
690 : 8527991 : if (ds1->len == ds2->len)
691 : 4894580 : return memcmp (ds1->s, ds2->s, 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. */
698 : : struct 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. */
745 : 402250 : class data_in
746 : : {
747 : : public:
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 */
769 : : extern class lto_input_block * lto_create_simple_input_block (
770 : : struct lto_file_decl_data *,
771 : : enum lto_section_type, const char **, size_t *);
772 : : extern void
773 : : lto_destroy_simple_input_block (struct lto_file_decl_data *,
774 : : enum lto_section_type,
775 : : class lto_input_block *, const char *, size_t);
776 : : extern void lto_set_in_hooks (struct lto_file_decl_data **,
777 : : lto_get_section_data_f *,
778 : : lto_free_section_data_f *);
779 : : extern struct lto_file_decl_data **lto_get_file_decl_data (void);
780 : : extern 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);
784 : : extern const char *lto_get_summary_section_data (struct lto_file_decl_data *,
785 : : enum lto_section_type,
786 : : size_t *);
787 : : extern const char *lto_get_raw_section_data (struct lto_file_decl_data *,
788 : : enum lto_section_type,
789 : : const char *, int, size_t *);
790 : : extern 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);
794 : : extern void lto_free_raw_section_data (struct lto_file_decl_data *,
795 : : enum lto_section_type,
796 : : const char *, const char *, size_t);
797 : : extern htab_t lto_create_renaming_table (void);
798 : : extern void lto_record_renamed_decl (struct lto_file_decl_data *,
799 : : const char *, const char *);
800 : : extern const char *lto_get_decl_name_mapping (struct lto_file_decl_data *,
801 : : const char *);
802 : : extern struct lto_in_decl_state *lto_new_in_decl_state (void);
803 : : extern void lto_delete_in_decl_state (struct lto_in_decl_state *);
804 : : extern struct lto_in_decl_state *lto_get_function_in_decl_state (
805 : : struct lto_file_decl_data *, tree);
806 : : extern void lto_free_function_in_decl_state (struct lto_in_decl_state *);
807 : : extern void lto_free_function_in_decl_state_for_node (symtab_node *);
808 : : extern void lto_section_overrun (class lto_input_block *) ATTRIBUTE_NORETURN;
809 : : extern 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 */
814 : : extern void lto_begin_section (const char *, bool);
815 : : extern void lto_end_section (void);
816 : : extern void lto_write_data (const void *, unsigned int);
817 : : extern void lto_write_raw_data (const void *, unsigned int);
818 : : extern void lto_write_stream (struct lto_output_stream *);
819 : : extern struct lto_simple_output_block *lto_create_simple_output_block (
820 : : enum lto_section_type);
821 : : extern void lto_destroy_simple_output_block (struct lto_simple_output_block *);
822 : : extern struct lto_out_decl_state *lto_new_out_decl_state (void);
823 : : extern void lto_delete_out_decl_state (struct lto_out_decl_state *);
824 : : extern struct lto_out_decl_state *lto_get_out_decl_state (void);
825 : : extern void lto_push_out_decl_state (struct lto_out_decl_state *);
826 : : extern struct lto_out_decl_state *lto_pop_out_decl_state (void);
827 : : extern void lto_record_function_out_decl_state (tree,
828 : : struct lto_out_decl_state *);
829 : : extern void lto_append_block (struct lto_output_stream *);
830 : :
831 : :
832 : : /* In lto-streamer.cc. */
833 : :
834 : : /* Set when streaming LTO for offloading compiler. */
835 : : extern bool lto_stream_offload_p;
836 : :
837 : : extern const char *lto_tag_name (enum LTO_tags);
838 : : extern char *lto_get_section_name (int, const char *, int,
839 : : struct lto_file_decl_data *);
840 : : extern void print_lto_report (const char *);
841 : : extern void lto_streamer_init (void);
842 : : extern bool gate_lto_out (void);
843 : : extern void lto_check_version (int, int, const char *);
844 : : extern void lto_streamer_hooks_init (void);
845 : :
846 : : /* In lto-streamer-in.cc */
847 : : extern void lto_input_cgraph (struct lto_file_decl_data *, const char *);
848 : : extern void lto_reader_init (void);
849 : : extern void lto_free_file_name_hash (void);
850 : : extern void lto_input_function_body (struct lto_file_decl_data *,
851 : : struct cgraph_node *,
852 : : const char *);
853 : : extern void lto_input_variable_constructor (struct lto_file_decl_data *,
854 : : struct varpool_node *,
855 : : const char *);
856 : : extern void lto_input_constructors_and_inits (struct lto_file_decl_data *,
857 : : const char *);
858 : : extern void lto_input_toplevel_asms (struct lto_file_decl_data *, int);
859 : : extern void lto_input_mode_table (struct lto_file_decl_data *);
860 : : extern class data_in *lto_data_in_create (struct lto_file_decl_data *,
861 : : const char *, unsigned,
862 : : vec<ld_plugin_symbol_resolution_t> );
863 : : extern void lto_data_in_delete (class data_in *);
864 : : extern void lto_input_data_block (class lto_input_block *, void *, size_t);
865 : : void lto_input_location (location_t *, struct bitpack_d *, class data_in *);
866 : : tree lto_input_tree_ref (class lto_input_block *, class data_in *,
867 : : struct function *, enum LTO_tags);
868 : : void lto_tag_check_set (enum LTO_tags, int, ...);
869 : : void lto_init_eh (void);
870 : : hashval_t lto_input_scc (class lto_input_block *, class data_in *,
871 : : unsigned *, unsigned *, bool);
872 : : tree lto_input_tree_1 (class lto_input_block *, class data_in *,
873 : : enum LTO_tags, hashval_t hash);
874 : : tree lto_input_tree (class lto_input_block *, class data_in *);
875 : : tree stream_read_tree_ref (class lto_input_block *, class data_in *);
876 : :
877 : :
878 : : /* In lto-streamer-out.cc */
879 : : extern void lto_register_decl_definition (tree, struct lto_file_decl_data *);
880 : : extern struct output_block *create_output_block (enum lto_section_type);
881 : : extern void destroy_output_block (struct output_block *);
882 : : extern void lto_output_tree (struct output_block *, tree, bool, bool);
883 : : extern void stream_write_tree_ref (struct output_block *, tree);
884 : : extern void lto_output_var_decl_ref (struct lto_out_decl_state *,
885 : : struct lto_output_stream *, tree);
886 : : extern void lto_output_fn_decl_ref (struct lto_out_decl_state *,
887 : : struct lto_output_stream *, tree);
888 : : extern tree lto_input_var_decl_ref (lto_input_block *, lto_file_decl_data *);
889 : : extern tree lto_input_fn_decl_ref (lto_input_block *, lto_file_decl_data *);
890 : : extern void lto_output_toplevel_asms (void);
891 : : extern void produce_asm (struct output_block *ob, tree fn);
892 : : extern void lto_output ();
893 : : extern void produce_asm_for_decls ();
894 : : void lto_output_decl_state_streams (struct output_block *,
895 : : struct lto_out_decl_state *);
896 : : void lto_output_decl_state_refs (struct output_block *,
897 : : struct lto_output_stream *,
898 : : struct lto_out_decl_state *);
899 : : void lto_output_location (struct output_block *, struct bitpack_d *,
900 : : location_t);
901 : : void lto_output_location_and_block (struct output_block *, struct bitpack_d *,
902 : : location_t);
903 : : void lto_output_init_mode_table (void);
904 : : void lto_prepare_function_for_streaming (cgraph_node *);
905 : :
906 : :
907 : : /* In lto-cgraph.cc */
908 : : extern bool asm_nodes_output;
909 : : lto_symtab_encoder_t lto_symtab_encoder_new (bool);
910 : : int lto_symtab_encoder_encode (lto_symtab_encoder_t, symtab_node *);
911 : : void lto_symtab_encoder_delete (lto_symtab_encoder_t);
912 : : bool lto_symtab_encoder_delete_node (lto_symtab_encoder_t, symtab_node *);
913 : : bool lto_symtab_encoder_encode_body_p (lto_symtab_encoder_t,
914 : : struct cgraph_node *);
915 : : bool lto_symtab_encoder_in_partition_p (lto_symtab_encoder_t,
916 : : symtab_node *);
917 : : void lto_set_symtab_encoder_in_partition (lto_symtab_encoder_t,
918 : : symtab_node *);
919 : :
920 : : bool lto_symtab_encoder_encode_initializer_p (lto_symtab_encoder_t,
921 : : varpool_node *);
922 : : void output_symtab (void);
923 : : void input_symtab (void);
924 : : void output_offload_tables (void);
925 : : void input_offload_tables (bool);
926 : : bool referenced_from_other_partition_p (struct ipa_ref_list *,
927 : : lto_symtab_encoder_t);
928 : : bool reachable_from_other_partition_p (struct cgraph_node *,
929 : : lto_symtab_encoder_t);
930 : : bool referenced_from_this_partition_p (symtab_node *,
931 : : lto_symtab_encoder_t);
932 : : bool reachable_from_this_partition_p (struct cgraph_node *,
933 : : lto_symtab_encoder_t);
934 : : lto_symtab_encoder_t compute_ltrans_boundary (lto_symtab_encoder_t encoder);
935 : : void select_what_to_stream (void);
936 : :
937 : : /* In omp-general.cc. */
938 : : void omp_lto_output_declare_variant_alt (lto_simple_output_block *,
939 : : cgraph_node *, lto_symtab_encoder_t);
940 : : void omp_lto_input_declare_variant_alt (lto_input_block *, cgraph_node *,
941 : : vec<symtab_node *>);
942 : :
943 : : /* In options-save.cc. */
944 : : void cl_target_option_stream_out (struct output_block *, struct bitpack_d *,
945 : : struct cl_target_option *);
946 : :
947 : : void cl_target_option_stream_in (class data_in *,
948 : : struct bitpack_d *,
949 : : struct cl_target_option *);
950 : :
951 : : void cl_optimization_stream_out (struct output_block *,
952 : : struct bitpack_d *, struct cl_optimization *);
953 : :
954 : : void cl_optimization_stream_in (class data_in *,
955 : : struct bitpack_d *, struct cl_optimization *);
956 : :
957 : :
958 : :
959 : : /* In lto-opts.cc. */
960 : : extern void lto_write_options (void);
961 : :
962 : :
963 : : /* Statistics gathered during LTO, WPA and LTRANS. */
964 : : extern struct lto_stats_d lto_stats;
965 : :
966 : : /* Section names corresponding to the values of enum lto_section_type. */
967 : : extern const char *lto_section_name[];
968 : :
969 : : /* Holds all the out decl states of functions output so far in the
970 : : current output file. */
971 : : extern vec<lto_out_decl_state_ptr> lto_function_decl_states;
972 : :
973 : : /* Return true if LTO tag TAG corresponds to a tree code. */
974 : : inline bool
975 : 4164727 : lto_tag_is_tree_code_p (enum LTO_tags tag)
976 : : {
977 : 4164727 : 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. */
982 : : inline bool
983 : 1363029 : lto_tag_is_gimple_code_p (enum LTO_tags tag)
984 : : {
985 : 1363029 : return (unsigned) tag >= LTO_first_gimple_tag
986 : 1363029 : && (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. */
993 : : inline enum LTO_tags
994 : 1627451 : lto_gimple_code_to_tag (enum gimple_code code)
995 : : {
996 : 1627451 : 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. */
1002 : : inline enum gimple_code
1003 : 1363029 : lto_tag_to_gimple_code (enum LTO_tags tag)
1004 : : {
1005 : 1363029 : gcc_assert (lto_tag_is_gimple_code_p (tag));
1006 : 1363029 : 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. */
1012 : : inline enum LTO_tags
1013 : 6843375 : lto_tree_code_to_tag (enum tree_code code)
1014 : : {
1015 : 6843375 : 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. */
1021 : : inline enum tree_code
1022 : 4164727 : lto_tag_to_tree_code (enum LTO_tags tag)
1023 : : {
1024 : 4164727 : gcc_assert (lto_tag_is_tree_code_p (tag));
1025 : 4164727 : return (enum tree_code) ((unsigned) tag - LTO_first_tree_tag);
1026 : : }
1027 : :
1028 : : /* Check that tag ACTUAL == EXPECTED. */
1029 : : inline void
1030 : 81955 : lto_tag_check (enum LTO_tags actual, enum LTO_tags expected)
1031 : : {
1032 : 81955 : if (actual != expected)
1033 : 0 : internal_error ("bytecode stream: expected tag %s instead of %s",
1034 : : lto_tag_name (expected), lto_tag_name (actual));
1035 : 81955 : }
1036 : :
1037 : : /* Check that tag ACTUAL is in the range [TAG1, TAG2]. */
1038 : : inline void
1039 : 9481 : lto_tag_check_range (enum LTO_tags actual, enum LTO_tags tag1,
1040 : : enum LTO_tags tag2)
1041 : : {
1042 : 9481 : if (actual < tag1 || actual > tag2)
1043 : 0 : 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 : 9481 : }
1049 : :
1050 : : /* Initialize an lto_out_decl_buffer ENCODER. */
1051 : : inline void
1052 : 181670 : lto_init_tree_ref_encoder (struct lto_tree_ref_encoder *encoder)
1053 : : {
1054 : 181670 : encoder->tree_hash_table = new hash_map<tree, unsigned> (251);
1055 : 181670 : encoder->trees.create (0);
1056 : 181670 : }
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. */
1061 : : inline void
1062 : 181670 : lto_destroy_tree_ref_encoder (struct lto_tree_ref_encoder *encoder)
1063 : : {
1064 : : /* Hash table may be delete already. */
1065 : 181670 : delete encoder->tree_hash_table;
1066 : 181670 : encoder->tree_hash_table = NULL;
1067 : 181670 : encoder->trees.release ();
1068 : 181670 : }
1069 : :
1070 : : /* Return the number of trees encoded in ENCODER. */
1071 : : inline unsigned int
1072 : 578482 : lto_tree_ref_encoder_size (struct lto_tree_ref_encoder *encoder)
1073 : : {
1074 : 1120744 : return encoder->trees.length ();
1075 : : }
1076 : :
1077 : : /* Return the IDX-th tree in ENCODER. */
1078 : : inline tree
1079 : 5045374 : lto_tree_ref_encoder_get_tree (struct lto_tree_ref_encoder *encoder,
1080 : : unsigned int idx)
1081 : : {
1082 : 5045374 : return encoder->trees[idx];
1083 : : }
1084 : :
1085 : : /* Return number of encoded nodes in ENCODER. */
1086 : : inline int
1087 : 17655231 : lto_symtab_encoder_size (lto_symtab_encoder_t encoder)
1088 : : {
1089 : 27758699 : 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 : :
1098 : : inline int
1099 : 12378286 : lto_symtab_encoder_lookup (lto_symtab_encoder_t encoder,
1100 : : symtab_node *node)
1101 : : {
1102 : 12378286 : size_t *slot = encoder->map->get (node);
1103 : 12378286 : return (slot && *slot ? *(slot) - 1 : LCC_NOT_FOUND);
1104 : : }
1105 : :
1106 : : /* Return true if iterator LSE points to nothing. */
1107 : : inline bool
1108 : 13750449 : lsei_end_p (lto_symtab_encoder_iterator lsei)
1109 : : {
1110 : 10069618 : return lsei.index >= (unsigned)lto_symtab_encoder_size (lsei.encoder);
1111 : : }
1112 : :
1113 : : /* Advance iterator LSE. */
1114 : : inline void
1115 : 10816320 : lsei_next (lto_symtab_encoder_iterator *lsei)
1116 : : {
1117 : 10816320 : lsei->index++;
1118 : 10816313 : }
1119 : :
1120 : : /* Return the node pointed to by LSI. */
1121 : : inline symtab_node *
1122 : 15509434 : lsei_node (lto_symtab_encoder_iterator lsei)
1123 : : {
1124 : 11177535 : return lsei.encoder->nodes[lsei.index].node;
1125 : : }
1126 : :
1127 : : /* Return the node pointed to by LSI. */
1128 : : inline struct cgraph_node *
1129 : 1192629 : lsei_cgraph_node (lto_symtab_encoder_iterator lsei)
1130 : : {
1131 : 1192629 : return dyn_cast<cgraph_node *> (lsei.encoder->nodes[lsei.index].node);
1132 : : }
1133 : :
1134 : : /* Return the node pointed to by LSI. */
1135 : : inline varpool_node *
1136 : 277598 : lsei_varpool_node (lto_symtab_encoder_iterator lsei)
1137 : : {
1138 : 277598 : return dyn_cast<varpool_node *> (lsei.encoder->nodes[lsei.index].node);
1139 : : }
1140 : :
1141 : : /* Return the cgraph node corresponding to REF using ENCODER. */
1142 : :
1143 : : inline symtab_node *
1144 : 5830279 : lto_symtab_encoder_deref (lto_symtab_encoder_t encoder, int ref)
1145 : : {
1146 : 5828613 : if (ref == LCC_NOT_FOUND)
1147 : : return NULL;
1148 : :
1149 : 5830279 : return encoder->nodes[ref].node;
1150 : : }
1151 : :
1152 : : /* Return an iterator to the first node in LSI. */
1153 : : inline lto_symtab_encoder_iterator
1154 : : lsei_start (lto_symtab_encoder_t encoder)
1155 : : {
1156 : : lto_symtab_encoder_iterator lsei;
1157 : :
1158 : 396229 : lsei.encoder = encoder;
1159 : 396228 : lsei.index = 0;
1160 : : return lsei;
1161 : : }
1162 : :
1163 : : /* Advance iterator LSE. */
1164 : : inline void
1165 : 680599 : lsei_next_in_partition (lto_symtab_encoder_iterator *lsei)
1166 : : {
1167 : 680599 : lsei_next (lsei);
1168 : 680599 : while (!lsei_end_p (*lsei)
1169 : 3382250 : && !lto_symtab_encoder_in_partition_p (lsei->encoder, lsei_node (*lsei)))
1170 : 458860 : lsei_next (lsei);
1171 : 680599 : }
1172 : :
1173 : : /* Return an iterator to the first node in LSI. */
1174 : : inline lto_symtab_encoder_iterator
1175 : 36515 : lsei_start_in_partition (lto_symtab_encoder_t encoder)
1176 : : {
1177 : 36515 : lto_symtab_encoder_iterator lsei = lsei_start (encoder);
1178 : :
1179 : 72642 : if (lsei_end_p (lsei))
1180 : 388 : return lsei;
1181 : 36127 : if (!lto_symtab_encoder_in_partition_p (encoder, lsei_node (lsei)))
1182 : 0 : lsei_next_in_partition (&lsei);
1183 : :
1184 : 36127 : return lsei;
1185 : : }
1186 : :
1187 : : /* Advance iterator LSE. */
1188 : : inline void
1189 : 1196073 : lsei_next_function_in_partition (lto_symtab_encoder_iterator *lsei)
1190 : : {
1191 : 1196073 : lsei_next (lsei);
1192 : 1196073 : while (!lsei_end_p (*lsei)
1193 : 23504248 : && (!is_a <cgraph_node *> (lsei_node (*lsei))
1194 : 3453168 : || !lto_symtab_encoder_in_partition_p (lsei->encoder, lsei_node (*lsei))))
1195 : 5571188 : lsei_next (lsei);
1196 : 1196073 : }
1197 : :
1198 : : /* Return an iterator to the first node in LSI. */
1199 : : inline lto_symtab_encoder_iterator
1200 : 270494 : lsei_start_function_in_partition (lto_symtab_encoder_t encoder)
1201 : : {
1202 : 270494 : lto_symtab_encoder_iterator lsei = lsei_start (encoder);
1203 : :
1204 : 538438 : if (lsei_end_p (lsei))
1205 : 2550 : return lsei;
1206 : 532452 : if (!is_a <cgraph_node *> (lsei_node (lsei))
1207 : 264508 : || !lto_symtab_encoder_in_partition_p (encoder, lsei_node (lsei)))
1208 : 3444 : lsei_next_function_in_partition (&lsei);
1209 : :
1210 : 267944 : return lsei;
1211 : : }
1212 : :
1213 : : /* Advance iterator LSE. */
1214 : : inline void
1215 : 309559 : lsei_next_variable_in_partition (lto_symtab_encoder_iterator *lsei)
1216 : : {
1217 : 309559 : lsei_next (lsei);
1218 : 309559 : while (!lsei_end_p (*lsei)
1219 : 1574756 : && (!is_a <varpool_node *> (lsei_node (*lsei))
1220 : 277005 : || !lto_symtab_encoder_in_partition_p (lsei->encoder, lsei_node (*lsei))))
1221 : 133876 : lsei_next (lsei);
1222 : 309559 : }
1223 : :
1224 : : /* Return an iterator to the first node in LSI. */
1225 : : inline lto_symtab_encoder_iterator
1226 : 32791 : lsei_start_variable_in_partition (lto_symtab_encoder_t encoder)
1227 : : {
1228 : 32791 : lto_symtab_encoder_iterator lsei = lsei_start (encoder);
1229 : :
1230 : 65345 : if (lsei_end_p (lsei))
1231 : 237 : return lsei;
1232 : 33147 : if (!is_a <varpool_node *> (lsei_node (lsei))
1233 : 593 : || !lto_symtab_encoder_in_partition_p (encoder, lsei_node (lsei)))
1234 : 31961 : lsei_next_variable_in_partition (&lsei);
1235 : :
1236 : 32554 : return lsei;
1237 : : }
1238 : :
1239 : : /* Entry for the delayed registering of decl -> DIE references. */
1240 : : struct dref_entry {
1241 : : tree decl;
1242 : : const char *sym;
1243 : : unsigned HOST_WIDE_INT off;
1244 : : };
1245 : :
1246 : : extern vec<dref_entry> dref_queue;
1247 : :
1248 : : extern FILE *streamer_dump_file;
1249 : :
1250 : : #endif /* GCC_LTO_STREAMER_H */
|