1 /* Data structures and declarations used for reading and writing
2 GIMPLE to a file stream.
3
4 Copyright (C) 2009, 2010, 2011 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 "tree.h"
28 #include "gimple.h"
29 #include "target.h"
30 #include "cgraph.h"
31 #include "vec.h"
32 #include "vecprim.h"
33 #include "alloc-pool.h"
34 #include "gcov-io.h"
35 #include "diagnostic.h"
36
37 /* Define when debugging the LTO streamer. This causes the writer
38 to output the numeric value for the memory address of the tree node
39 being emitted. When debugging a problem in the reader, check the
40 original address that the writer was emitting using lto_orig_address_get.
41 With this value, set a breakpoint in the writer (e.g., lto_output_tree)
42 to trace how the faulty node is being emitted. */
43 /* #define LTO_STREAMER_DEBUG 1 */
44
45 /* The encoding for a function consists of the following sections:
46
47 1) The header.
48 2) FIELD_DECLS.
49 3) FUNCTION_DECLS.
50 4) global VAR_DECLS.
51 5) type_decls
52 6) types.
53 7) Names for the labels that have names
54 8) The SSA names.
55 9) The control flow graph.
56 10-11)Gimple for local decls.
57 12) Gimple for the function.
58 13) Strings.
59
60 1) THE HEADER.
61 2-6) THE GLOBAL DECLS AND TYPES.
62
63 The global decls and types are encoded in the same way. For each
64 entry, there is word with the offset within the section to the
65 entry.
66
67 7) THE LABEL NAMES.
68
69 Since most labels do not have names, this section my be of zero
70 length. It consists of an array of string table references, one
71 per label. In the lto code, the labels are given either
72 positive or negative indexes. the positive ones have names and
73 the negative ones do not. The positive index can be used to
74 find the name in this array.
75
76 9) THE CFG.
77
78 10) Index into the local decls. Since local decls can have local
79 decls inside them, they must be read in randomly in order to
80 properly restore them.
81
82 11-12) GIMPLE FOR THE LOCAL DECLS AND THE FUNCTION BODY.
83
84 The gimple consists of a set of records.
85
86 THE FUNCTION
87
88 At the top level of (8) is the function. It consists of five
89 pieces:
90
91 LTO_function - The tag.
92 eh tree - This is all of the exception handling regions
93 put out in a post order traversial of the
94 tree. Siblings are output as lists terminated
95 by a 0. The set of fields matches the fields
96 defined in except.c.
97
98 last_basic_block - in uleb128 form.
99
100 basic blocks - This is the set of basic blocks.
101
102 zero - The termination of the basic blocks.
103
104 BASIC BLOCKS
105
106 There are two forms of basic blocks depending on if they are
107 empty or not.
108
109 The basic block consists of:
110
111 LTO_bb1 or LTO_bb0 - The tag.
112
113 bb->index - the index in uleb128 form.
114
115 #succs - The number of successors un uleb128 form.
116
117 the successors - For each edge, a pair. The first of the
118 pair is the index of the successor in
119 uleb128 form and the second are the flags in
120 uleb128 form.
121
122 the statements - A gimple tree, as described above.
123 These are only present for LTO_BB1.
124 Following each statement is an optional
125 exception handling record LTO_eh_region
126 which contains the region number (for
127 regions >= 0).
128
129 zero - This is only present for LTO_BB1 and is used
130 to terminate the statements and exception
131 regions within this block.
132
133 12) STRINGS
134
135 String are represented in the table as pairs, a length in ULEB128
136 form followed by the data for the string. */
137
138 /* The string that is the prefix on the section names we make for lto.
139 For decls the DECL_ASSEMBLER_NAME is appended to make the section
140 name for the functions and static_initializers. For other types of
141 sections a '.' and the section type are appended. */
142 #define LTO_SECTION_NAME_PREFIX ".gnu.lto_"
143
144 #define LTO_major_version 2
145 #define LTO_minor_version 1
146
147 typedef unsigned char lto_decl_flags_t;
148
149
150 /* Tags representing the various IL objects written to the bytecode file
151 (GIMPLE statements, basic blocks, EH regions, tree nodes, etc).
152
153 NOTE, when adding new LTO tags, also update lto_tag_name. */
154 enum LTO_tags
155 {
156 LTO_null = 0,
157
158 /* Reserve enough entries to fit all the tree and gimple codes handled
159 by the streamer. This guarantees that:
160
161 1- Given a tree code C:
162 enum LTO_tags tag == C + 1
163
164 2- Given a gimple code C:
165 enum LTO_tags tag == C + NUM_TREE_CODES + 1
166
167 Conversely, to map between LTO tags and tree/gimple codes, the
168 reverse operation must be applied. */
169 LTO_bb0 = 1 + MAX_TREE_CODES + LAST_AND_UNUSED_GIMPLE_CODE,
170 LTO_bb1,
171
172 /* EH region holding the previous statement. */
173 LTO_eh_region,
174
175 /* An MD or NORMAL builtin. Only the code and class are streamed out. */
176 LTO_builtin_decl,
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 /* Special for global streamer. Reference to previously-streamed node. */
197 LTO_tree_pickle_reference,
198
199 /* References to indexable tree nodes. These objects are stored in
200 tables that are written separately from the function bodies that
201 reference them. This way they can be instantiated even when the
202 referencing functions aren't (e.g., during WPA) and it also allows
203 functions to be copied from one file to another without having
204 to unpickle the body first (the references are location
205 independent).
206
207 NOTE, do not regroup these values as the grouping is exposed
208 in the range checks done in lto_input_tree. */
209 LTO_field_decl_ref, /* Do not change. */
210 LTO_function_decl_ref,
211 LTO_label_decl_ref,
212 LTO_namespace_decl_ref,
213 LTO_result_decl_ref,
214 LTO_ssa_name_ref,
215 LTO_type_decl_ref,
216 LTO_type_ref,
217 LTO_const_decl_ref,
218 LTO_imported_decl_ref,
219 LTO_translation_unit_decl_ref,
220 LTO_global_decl_ref, /* Do not change. */
221
222 /* This tag must always be last. */
223 LTO_NUM_TAGS
224 };
225
226
227 /* Set of section types that are in an LTO file. This list will grow
228 as the number of IPA passes grows since each IPA pass will need its
229 own section type to store its summary information.
230
231 When adding a new section type, you must also extend the
232 LTO_SECTION_NAME array in lto-section-in.c. */
233 enum lto_section_type
234 {
235 LTO_section_decls = 0,
236 LTO_section_function_body,
237 LTO_section_static_initializer,
238 LTO_section_cgraph,
239 LTO_section_varpool,
240 LTO_section_refs,
241 LTO_section_asm,
242 LTO_section_jump_functions,
243 LTO_section_ipa_pure_const,
244 LTO_section_ipa_reference,
245 LTO_section_symtab,
246 LTO_section_opts,
247 LTO_section_cgraph_opt_sum,
248 LTO_section_inline_summary,
249 LTO_N_SECTION_TYPES /* Must be last. */
250 };
251
252 /* Indices to the various function, type and symbol streams. */
253 typedef enum
254 {
255 LTO_DECL_STREAM_TYPE = 0, /* Must be first. */
256 LTO_DECL_STREAM_FIELD_DECL,
257 LTO_DECL_STREAM_FN_DECL,
258 LTO_DECL_STREAM_VAR_DECL,
259 LTO_DECL_STREAM_TYPE_DECL,
260 LTO_DECL_STREAM_NAMESPACE_DECL,
261 LTO_DECL_STREAM_LABEL_DECL,
262 LTO_N_DECL_STREAMS
263 } lto_decl_stream_e_t;
264
265 typedef enum ld_plugin_symbol_resolution ld_plugin_symbol_resolution_t;
266 DEF_VEC_I(ld_plugin_symbol_resolution_t);
267 DEF_VEC_ALLOC_I(ld_plugin_symbol_resolution_t, heap);
268
269
270 /* Macro to define convenience functions for type and decl streams
271 in lto_file_decl_data. */
272 #define DEFINE_DECL_STREAM_FUNCS(UPPER_NAME, name) \
273 static inline tree \
274 lto_file_decl_data_get_ ## name (struct lto_file_decl_data *data, \
275 unsigned int idx) \
276 { \
277 struct lto_in_decl_state *state = data->current_decl_state; \
278 gcc_assert (idx < state->streams[LTO_DECL_STREAM_## UPPER_NAME].size); \
279 return state->streams[LTO_DECL_STREAM_## UPPER_NAME].trees[idx]; \
280 } \
281 \
282 static inline unsigned int \
283 lto_file_decl_data_num_ ## name ## s (struct lto_file_decl_data *data) \
284 { \
285 struct lto_in_decl_state *state = data->current_decl_state; \
286 return state->streams[LTO_DECL_STREAM_## UPPER_NAME].size; \
287 }
288
289
290 /* Return a char pointer to the start of a data stream for an lto pass
291 or function. The first parameter is the file data that contains
292 the information. The second parameter is the type of information
293 to be obtained. The third parameter is the name of the function
294 and is only used when finding a function body; otherwise it is
295 NULL. The fourth parameter is the length of the data returned. */
296 typedef const char* (lto_get_section_data_f) (struct lto_file_decl_data *,
297 enum lto_section_type,
298 const char *,
299 size_t *);
300
301 /* Return the data found from the above call. The first three
302 parameters are the same as above. The fourth parameter is the data
303 itself and the fifth is the lenght of the data. */
304 typedef void (lto_free_section_data_f) (struct lto_file_decl_data *,
305 enum lto_section_type,
306 const char *,
307 const char *,
308 size_t);
309
310 /* Structure used as buffer for reading an LTO file. */
311 struct lto_input_block
312 {
313 const char *data;
314 unsigned int p;
315 unsigned int len;
316 };
317
318 #define LTO_INIT_INPUT_BLOCK(BASE,D,P,L) \
319 do { \
320 BASE.data = D; \
321 BASE.p = P; \
322 BASE.len = L; \
323 } while (0)
324
325 #define LTO_INIT_INPUT_BLOCK_PTR(BASE,D,P,L) \
326 do { \
327 BASE->data = D; \
328 BASE->p = P; \
329 BASE->len = L; \
330 } while (0)
331
332
333 /* The is the first part of the record for a function or constructor
334 in the .o file. */
335 struct lto_header
336 {
337 int16_t major_version;
338 int16_t minor_version;
339 enum lto_section_type section_type;
340 };
341
342 /* The header for a function body. */
343 struct lto_function_header
344 {
345 /* The header for all types of sections. */
346 struct lto_header lto_header;
347
348 /* Number of labels with names. */
349 int32_t num_named_labels;
350
351 /* Number of labels without names. */
352 int32_t num_unnamed_labels;
353
354 /* Size compressed or 0 if not compressed. */
355 int32_t compressed_size;
356
357 /* Size of names for named labels. */
358 int32_t named_label_size;
359
360 /* Size of the cfg. */
361 int32_t cfg_size;
362
363 /* Size of main gimple body of function. */
364 int32_t main_size;
365
366 /* Size of the string table. */
367 int32_t string_size;
368 };
369
370
371 /* Structure describing a symbol section. */
372 struct lto_decl_header
373 {
374 /* The header for all types of sections. */
375 struct lto_header lto_header;
376
377 /* Size of region for decl state. */
378 int32_t decl_state_size;
379
380 /* Number of nodes in globals stream. */
381 int32_t num_nodes;
382
383 /* Size of region for expressions, decls, types, etc. */
384 int32_t main_size;
385
386 /* Size of the string table. */
387 int32_t string_size;
388 };
389
390
391 /* Structure describing top level asm()s. */
392 struct lto_asm_header
393 {
394 /* The header for all types of sections. */
395 struct lto_header lto_header;
396
397 /* Size compressed or 0 if not compressed. */
398 int32_t compressed_size;
399
400 /* Size of region for expressions, decls, types, etc. */
401 int32_t main_size;
402
403 /* Size of the string table. */
404 int32_t string_size;
405 };
406
407
408 /* Statistics gathered during LTO, WPA and LTRANS. */
409 struct lto_stats_d
410 {
411 unsigned HOST_WIDE_INT num_input_cgraph_nodes;
412 unsigned HOST_WIDE_INT num_output_cgraph_nodes;
413 unsigned HOST_WIDE_INT num_input_files;
414 unsigned HOST_WIDE_INT num_output_files;
415 unsigned HOST_WIDE_INT num_cgraph_partitions;
416 unsigned HOST_WIDE_INT section_size[LTO_N_SECTION_TYPES];
417 unsigned HOST_WIDE_INT num_function_bodies;
418 unsigned HOST_WIDE_INT num_trees[NUM_TREE_CODES];
419 unsigned HOST_WIDE_INT num_output_il_bytes;
420 unsigned HOST_WIDE_INT num_compressed_il_bytes;
421 unsigned HOST_WIDE_INT num_input_il_bytes;
422 unsigned HOST_WIDE_INT num_uncompressed_il_bytes;
423 };
424
425 /* Encoder data structure used to stream callgraph nodes. */
426 struct lto_cgraph_encoder_d
427 {
428 /* Map nodes to reference number. */
429 struct pointer_map_t *map;
430
431 /* Map reference number to node. */
432 VEC(cgraph_node_ptr,heap) *nodes;
433
434 /* Map of nodes where we want to output body. */
435 struct pointer_set_t *body;
436 };
437
438 typedef struct lto_cgraph_encoder_d *lto_cgraph_encoder_t;
439
440 /* Return number of encoded nodes in ENCODER. */
441
442 static inline int
lto_cgraph_encoder_size(lto_cgraph_encoder_t encoder)443 lto_cgraph_encoder_size (lto_cgraph_encoder_t encoder)
444 {
445 return VEC_length (cgraph_node_ptr, encoder->nodes);
446 }
447
448
449 /* Encoder data structure used to stream callgraph nodes. */
450 struct lto_varpool_encoder_d
451 {
452 /* Map nodes to reference number. */
453 struct pointer_map_t *map;
454
455 /* Map reference number to node. */
456 VEC(varpool_node_ptr,heap) *nodes;
457
458 /* Map of nodes where we want to output initializer. */
459 struct pointer_set_t *initializer;
460 };
461 typedef struct lto_varpool_encoder_d *lto_varpool_encoder_t;
462
463 /* Return number of encoded nodes in ENCODER. */
464
465 static inline int
lto_varpool_encoder_size(lto_varpool_encoder_t encoder)466 lto_varpool_encoder_size (lto_varpool_encoder_t encoder)
467 {
468 return VEC_length (varpool_node_ptr, encoder->nodes);
469 }
470
471 /* Mapping from indices to trees. */
472 struct GTY(()) lto_tree_ref_table
473 {
474 /* Array of referenced trees . */
475 tree * GTY((length ("%h.size"))) trees;
476
477 /* Size of array. */
478 unsigned int size;
479 };
480
481
482 /* Mapping between trees and slots in an array. */
483 struct lto_decl_slot
484 {
485 tree t;
486 int slot_num;
487 };
488
489
490 /* The lto_tree_ref_encoder struct is used to encode trees into indices. */
491
492 struct lto_tree_ref_encoder
493 {
494 htab_t tree_hash_table; /* Maps pointers to indices. */
495 unsigned int next_index; /* Next available index. */
496 VEC(tree,heap) *trees; /* Maps indices to pointers. */
497 };
498
499
500 /* Structure to hold states of input scope. */
501 struct GTY(()) lto_in_decl_state
502 {
503 /* Array of lto_in_decl_buffers to store type and decls streams. */
504 struct lto_tree_ref_table streams[LTO_N_DECL_STREAMS];
505
506 /* If this in-decl state is associated with a function. FN_DECL
507 point to the FUNCTION_DECL. */
508 tree fn_decl;
509 };
510
511 typedef struct lto_in_decl_state *lto_in_decl_state_ptr;
512
513
514 /* The structure that holds all of the vectors of global types,
515 decls and cgraph nodes used in the serialization of this file. */
516 struct lto_out_decl_state
517 {
518 /* The buffers contain the sets of decls of various kinds and types we have
519 seen so far and the indexes assigned to them. */
520 struct lto_tree_ref_encoder streams[LTO_N_DECL_STREAMS];
521
522 /* Encoder for cgraph nodes. */
523 lto_cgraph_encoder_t cgraph_node_encoder;
524
525 /* Encoder for varpool nodes. */
526 lto_varpool_encoder_t varpool_node_encoder;
527
528 /* If this out-decl state belongs to a function, fn_decl points to that
529 function. Otherwise, it is NULL. */
530 tree fn_decl;
531 };
532
533 typedef struct lto_out_decl_state *lto_out_decl_state_ptr;
534
535 DEF_VEC_P(lto_out_decl_state_ptr);
536 DEF_VEC_ALLOC_P(lto_out_decl_state_ptr, heap);
537
538 /* Compact representation of a index <-> resolution pair. Unpacked to an
539 vector later. */
540 struct res_pair
541 {
542 ld_plugin_symbol_resolution_t res;
543 unsigned index;
544 };
545 typedef struct res_pair res_pair;
546
547 DEF_VEC_O(res_pair);
548 DEF_VEC_ALLOC_O(res_pair, heap);
549
550 /* One of these is allocated for each object file that being compiled
551 by lto. This structure contains the tables that are needed by the
552 serialized functions and ipa passes to connect themselves to the
553 global types and decls as they are reconstituted. */
554 struct GTY(()) lto_file_decl_data
555 {
556 /* Decl state currently used. */
557 struct lto_in_decl_state *current_decl_state;
558
559 /* Decl state corresponding to regions outside of any functions
560 in the compilation unit. */
561 struct lto_in_decl_state *global_decl_state;
562
563 /* Table of cgraph nodes present in this file. */
564 lto_cgraph_encoder_t GTY((skip)) cgraph_node_encoder;
565
566 /* Table of varpool nodes present in this file. */
567 lto_varpool_encoder_t GTY((skip)) varpool_node_encoder;
568
569 /* Hash table maps lto-related section names to location in file. */
570 htab_t GTY((param_is (struct lto_in_decl_state))) function_decl_states;
571
572 /* The .o file that these offsets relate to. */
573 const char *GTY((skip)) file_name;
574
575 /* Hash table maps lto-related section names to location in file. */
576 htab_t GTY((skip)) section_hash_table;
577
578 /* Hash new name of renamed global declaration to its original name. */
579 htab_t GTY((skip)) renaming_hash_table;
580
581 /* Linked list used temporarily in reader */
582 struct lto_file_decl_data *next;
583
584 /* Sub ID for merged objects. */
585 unsigned HOST_WIDE_INT id;
586
587 /* Symbol resolutions for this file */
588 VEC(res_pair, heap) * GTY((skip)) respairs;
589 unsigned max_index;
590
591 struct gcov_ctr_summary GTY((skip)) profile_info;
592 };
593
594 typedef struct lto_file_decl_data *lto_file_decl_data_ptr;
595
596 struct lto_char_ptr_base
597 {
598 char *ptr;
599 };
600
601 /* An incore byte stream to buffer the various parts of the function.
602 The entire structure should be zeroed when created. The record
603 consists of a set of blocks. The first sizeof (ptr) bytes are used
604 as a chain, and the rest store the bytes to be written. */
605 struct lto_output_stream
606 {
607 /* The pointer to the first block in the stream. */
608 struct lto_char_ptr_base * first_block;
609
610 /* The pointer to the last and current block in the stream. */
611 struct lto_char_ptr_base * current_block;
612
613 /* The pointer to where the next char should be written. */
614 char * current_pointer;
615
616 /* The number of characters left in the current block. */
617 unsigned int left_in_block;
618
619 /* The block size of the last block allocated. */
620 unsigned int block_size;
621
622 /* The total number of characters written. */
623 unsigned int total_size;
624 };
625
626 /* The is the first part of the record in an LTO file for many of the
627 IPA passes. */
628 struct lto_simple_header
629 {
630 /* The header for all types of sections. */
631 struct lto_header lto_header;
632
633 /* Size of main gimple body of function. */
634 int32_t main_size;
635
636 /* Size of main stream when compressed. */
637 int32_t compressed_size;
638 };
639
640 /* A simple output block. This can be used for simple IPA passes that
641 do not need more than one stream. */
642 struct lto_simple_output_block
643 {
644 enum lto_section_type section_type;
645 struct lto_out_decl_state *decl_state;
646
647 /* The stream that the main tree codes are written to. */
648 struct lto_output_stream *main_stream;
649 };
650
651 /* Data structure holding all the data and descriptors used when writing
652 an LTO file. */
653 struct output_block
654 {
655 enum lto_section_type section_type;
656 struct lto_out_decl_state *decl_state;
657
658 /* The stream that the main tree codes are written to. */
659 struct lto_output_stream *main_stream;
660
661 /* The stream that contains the string table. */
662 struct lto_output_stream *string_stream;
663
664 /* The stream that contains the cfg. */
665 struct lto_output_stream *cfg_stream;
666
667 /* The hash table that contains the set of strings we have seen so
668 far and the indexes assigned to them. */
669 htab_t string_hash_table;
670
671 /* The current cgraph_node that we are currently serializing. Null
672 if we are serializing something else. */
673 struct cgraph_node *cgraph_node;
674
675 /* These are the last file and line that were seen in the stream.
676 If the current node differs from these, it needs to insert
677 something into the stream and fix these up. */
678 const char *current_file;
679 int current_line;
680 int current_col;
681
682 /* True if writing globals and types. */
683 bool global;
684
685 /* Cache of nodes written in this section. */
686 struct streamer_tree_cache_d *writer_cache;
687
688 /* All data persistent across whole duration of output block
689 can go here. */
690 struct obstack obstack;
691 };
692
693
694 /* Data and descriptors used when reading from an LTO file. */
695 struct data_in
696 {
697 /* The global decls and types. */
698 struct lto_file_decl_data *file_data;
699
700 /* All of the labels. */
701 tree *labels;
702
703 /* The string table. */
704 const char *strings;
705
706 /* The length of the string table. */
707 unsigned int strings_len;
708
709 /* Number of named labels. Used to find the index of unnamed labels
710 since they share space with the named labels. */
711 unsigned int num_named_labels;
712
713 /* Number of unnamed labels. */
714 unsigned int num_unnamed_labels;
715
716 const char *current_file;
717 int current_line;
718 int current_col;
719
720 /* Maps each reference number to the resolution done by the linker. */
721 VEC(ld_plugin_symbol_resolution_t,heap) *globals_resolution;
722
723 /* Cache of pickled nodes. */
724 struct streamer_tree_cache_d *reader_cache;
725 };
726
727
728 /* In lto-section-in.c */
729 extern struct lto_input_block * lto_create_simple_input_block (
730 struct lto_file_decl_data *,
731 enum lto_section_type, const char **, size_t *);
732 extern void
733 lto_destroy_simple_input_block (struct lto_file_decl_data *,
734 enum lto_section_type,
735 struct lto_input_block *, const char *, size_t);
736 extern void lto_set_in_hooks (struct lto_file_decl_data **,
737 lto_get_section_data_f *,
738 lto_free_section_data_f *);
739 extern struct lto_file_decl_data **lto_get_file_decl_data (void);
740 extern const char *lto_get_section_data (struct lto_file_decl_data *,
741 enum lto_section_type,
742 const char *, size_t *);
743 extern void lto_free_section_data (struct lto_file_decl_data *,
744 enum lto_section_type,
745 const char *, const char *, size_t);
746 extern htab_t lto_create_renaming_table (void);
747 extern void lto_record_renamed_decl (struct lto_file_decl_data *,
748 const char *, const char *);
749 extern const char *lto_get_decl_name_mapping (struct lto_file_decl_data *,
750 const char *);
751 extern struct lto_in_decl_state *lto_new_in_decl_state (void);
752 extern void lto_delete_in_decl_state (struct lto_in_decl_state *);
753 extern hashval_t lto_hash_in_decl_state (const void *);
754 extern int lto_eq_in_decl_state (const void *, const void *);
755 extern struct lto_in_decl_state *lto_get_function_in_decl_state (
756 struct lto_file_decl_data *, tree);
757 extern void lto_section_overrun (struct lto_input_block *) ATTRIBUTE_NORETURN;
758 extern void lto_value_range_error (const char *,
759 HOST_WIDE_INT, HOST_WIDE_INT,
760 HOST_WIDE_INT) ATTRIBUTE_NORETURN;
761
762 /* In lto-section-out.c */
763 extern hashval_t lto_hash_decl_slot_node (const void *);
764 extern int lto_eq_decl_slot_node (const void *, const void *);
765 extern hashval_t lto_hash_type_slot_node (const void *);
766 extern int lto_eq_type_slot_node (const void *, const void *);
767 extern void lto_begin_section (const char *, bool);
768 extern void lto_end_section (void);
769 extern void lto_write_stream (struct lto_output_stream *);
770 extern void lto_output_data_stream (struct lto_output_stream *, const void *,
771 size_t);
772 extern bool lto_output_decl_index (struct lto_output_stream *,
773 struct lto_tree_ref_encoder *,
774 tree, unsigned int *);
775 extern void lto_output_field_decl_index (struct lto_out_decl_state *,
776 struct lto_output_stream *, tree);
777 extern void lto_output_fn_decl_index (struct lto_out_decl_state *,
778 struct lto_output_stream *, tree);
779 extern void lto_output_namespace_decl_index (struct lto_out_decl_state *,
780 struct lto_output_stream *, tree);
781 extern void lto_output_var_decl_index (struct lto_out_decl_state *,
782 struct lto_output_stream *, tree);
783 extern void lto_output_type_decl_index (struct lto_out_decl_state *,
784 struct lto_output_stream *, tree);
785 extern void lto_output_type_ref_index (struct lto_out_decl_state *,
786 struct lto_output_stream *, tree);
787 extern struct lto_simple_output_block *lto_create_simple_output_block (
788 enum lto_section_type);
789 extern void lto_destroy_simple_output_block (struct lto_simple_output_block *);
790 extern struct lto_out_decl_state *lto_new_out_decl_state (void);
791 extern void lto_delete_out_decl_state (struct lto_out_decl_state *);
792 extern struct lto_out_decl_state *lto_get_out_decl_state (void);
793 extern void lto_push_out_decl_state (struct lto_out_decl_state *);
794 extern struct lto_out_decl_state *lto_pop_out_decl_state (void);
795 extern void lto_record_function_out_decl_state (tree,
796 struct lto_out_decl_state *);
797 extern void lto_append_block (struct lto_output_stream *);
798
799
800 /* In lto-streamer.c. */
801 extern const char *lto_tag_name (enum LTO_tags);
802 extern bitmap lto_bitmap_alloc (void);
803 extern void lto_bitmap_free (bitmap);
804 extern char *lto_get_section_name (int, const char *, struct lto_file_decl_data *);
805 extern void print_lto_report (void);
806 extern void lto_streamer_init (void);
807 extern bool gate_lto_out (void);
808 #ifdef LTO_STREAMER_DEBUG
809 extern void lto_orig_address_map (tree, intptr_t);
810 extern intptr_t lto_orig_address_get (tree);
811 extern void lto_orig_address_remove (tree);
812 #endif
813 extern void lto_check_version (int, int);
814 extern void lto_streamer_hooks_init (void);
815
816 /* In lto-streamer-in.c */
817 extern void lto_input_cgraph (struct lto_file_decl_data *, const char *);
818 extern void lto_reader_init (void);
819 extern void lto_input_function_body (struct lto_file_decl_data *, tree,
820 const char *);
821 extern void lto_input_constructors_and_inits (struct lto_file_decl_data *,
822 const char *);
823 extern void lto_input_toplevel_asms (struct lto_file_decl_data *, int);
824 extern struct data_in *lto_data_in_create (struct lto_file_decl_data *,
825 const char *, unsigned,
826 VEC(ld_plugin_symbol_resolution_t,heap) *);
827 extern void lto_data_in_delete (struct data_in *);
828 extern void lto_input_data_block (struct lto_input_block *, void *, size_t);
829 location_t lto_input_location (struct lto_input_block *, struct data_in *);
830 tree lto_input_tree_ref (struct lto_input_block *, struct data_in *,
831 struct function *, enum LTO_tags);
832 void lto_tag_check_set (enum LTO_tags, int, ...);
833 void lto_init_eh (void);
834 tree lto_input_tree (struct lto_input_block *, struct data_in *);
835
836
837 /* In lto-streamer-out.c */
838 extern void lto_register_decl_definition (tree, struct lto_file_decl_data *);
839 extern struct output_block *create_output_block (enum lto_section_type);
840 extern void destroy_output_block (struct output_block *);
841 extern void lto_output_tree (struct output_block *, tree, bool, bool);
842 extern void lto_output_toplevel_asms (void);
843 extern void produce_asm (struct output_block *ob, tree fn);
844 void lto_output_decl_state_streams (struct output_block *,
845 struct lto_out_decl_state *);
846 void lto_output_decl_state_refs (struct output_block *,
847 struct lto_output_stream *,
848 struct lto_out_decl_state *);
849 void lto_output_location (struct output_block *, location_t);
850
851
852 /* In lto-cgraph.c */
853 struct cgraph_node *lto_cgraph_encoder_deref (lto_cgraph_encoder_t, int);
854 int lto_cgraph_encoder_lookup (lto_cgraph_encoder_t, struct cgraph_node *);
855 lto_cgraph_encoder_t lto_cgraph_encoder_new (void);
856 int lto_cgraph_encoder_encode (lto_cgraph_encoder_t, struct cgraph_node *);
857 void lto_cgraph_encoder_delete (lto_cgraph_encoder_t);
858 bool lto_cgraph_encoder_encode_body_p (lto_cgraph_encoder_t,
859 struct cgraph_node *);
860
861 bool lto_varpool_encoder_encode_body_p (lto_varpool_encoder_t,
862 struct varpool_node *);
863 struct varpool_node *lto_varpool_encoder_deref (lto_varpool_encoder_t, int);
864 int lto_varpool_encoder_lookup (lto_varpool_encoder_t, struct varpool_node *);
865 lto_varpool_encoder_t lto_varpool_encoder_new (void);
866 int lto_varpool_encoder_encode (lto_varpool_encoder_t, struct varpool_node *);
867 void lto_varpool_encoder_delete (lto_varpool_encoder_t);
868 bool lto_varpool_encoder_encode_initializer_p (lto_varpool_encoder_t,
869 struct varpool_node *);
870 void output_cgraph (cgraph_node_set, varpool_node_set);
871 void input_cgraph (void);
872 bool referenced_from_other_partition_p (struct ipa_ref_list *,
873 cgraph_node_set,
874 varpool_node_set vset);
875 bool reachable_from_other_partition_p (struct cgraph_node *,
876 cgraph_node_set);
877 bool referenced_from_this_partition_p (struct ipa_ref_list *,
878 cgraph_node_set,
879 varpool_node_set vset);
880 bool reachable_from_this_partition_p (struct cgraph_node *,
881 cgraph_node_set);
882 void compute_ltrans_boundary (struct lto_out_decl_state *state,
883 cgraph_node_set, varpool_node_set);
884
885
886 /* In lto-symtab.c. */
887 extern void lto_symtab_register_decl (tree, ld_plugin_symbol_resolution_t,
888 struct lto_file_decl_data *);
889 extern void lto_symtab_merge_decls (void);
890 extern void lto_symtab_merge_cgraph_nodes (void);
891 extern tree lto_symtab_prevailing_decl (tree decl);
892 extern enum ld_plugin_symbol_resolution lto_symtab_get_resolution (tree decl);
893 extern void lto_symtab_free (void);
894 extern GTY(()) VEC(tree,gc) *lto_global_var_decls;
895
896
897 /* In lto-opts.c. */
898 extern void lto_write_options (void);
899
900
901 /* In lto-wpa-fixup.c */
902 void lto_mark_nothrow_fndecl (tree);
903 void lto_fixup_nothrow_decls (void);
904
905
906 /* Statistics gathered during LTO, WPA and LTRANS. */
907 extern struct lto_stats_d lto_stats;
908
909 /* Section names corresponding to the values of enum lto_section_type. */
910 extern const char *lto_section_name[];
911
912 /* Holds all the out decl states of functions output so far in the
913 current output file. */
914 extern VEC(lto_out_decl_state_ptr, heap) *lto_function_decl_states;
915
916 /* Return true if LTO tag TAG corresponds to a tree code. */
917 static inline bool
lto_tag_is_tree_code_p(enum LTO_tags tag)918 lto_tag_is_tree_code_p (enum LTO_tags tag)
919 {
920 return tag > LTO_null && (unsigned) tag <= MAX_TREE_CODES;
921 }
922
923
924 /* Return true if LTO tag TAG corresponds to a gimple code. */
925 static inline bool
lto_tag_is_gimple_code_p(enum LTO_tags tag)926 lto_tag_is_gimple_code_p (enum LTO_tags tag)
927 {
928 return (unsigned) tag >= NUM_TREE_CODES + 1
929 && (unsigned) tag < 1 + NUM_TREE_CODES + LAST_AND_UNUSED_GIMPLE_CODE;
930 }
931
932
933 /* Return the LTO tag corresponding to gimple code CODE. See enum
934 LTO_tags for details on the conversion. */
935 static inline enum LTO_tags
lto_gimple_code_to_tag(enum gimple_code code)936 lto_gimple_code_to_tag (enum gimple_code code)
937 {
938 return (enum LTO_tags) ((unsigned) code + NUM_TREE_CODES + 1);
939 }
940
941
942 /* Return the GIMPLE code corresponding to TAG. See enum LTO_tags for
943 details on the conversion. */
944 static inline enum gimple_code
lto_tag_to_gimple_code(enum LTO_tags tag)945 lto_tag_to_gimple_code (enum LTO_tags tag)
946 {
947 gcc_assert (lto_tag_is_gimple_code_p (tag));
948 return (enum gimple_code) ((unsigned) tag - NUM_TREE_CODES - 1);
949 }
950
951
952 /* Return the LTO tag corresponding to tree code CODE. See enum
953 LTO_tags for details on the conversion. */
954 static inline enum LTO_tags
lto_tree_code_to_tag(enum tree_code code)955 lto_tree_code_to_tag (enum tree_code code)
956 {
957 return (enum LTO_tags) ((unsigned) code + 1);
958 }
959
960
961 /* Return the tree code corresponding to TAG. See enum LTO_tags for
962 details on the conversion. */
963 static inline enum tree_code
lto_tag_to_tree_code(enum LTO_tags tag)964 lto_tag_to_tree_code (enum LTO_tags tag)
965 {
966 gcc_assert (lto_tag_is_tree_code_p (tag));
967 return (enum tree_code) ((unsigned) tag - 1);
968 }
969
970 /* Check that tag ACTUAL == EXPECTED. */
971 static inline void
lto_tag_check(enum LTO_tags actual,enum LTO_tags expected)972 lto_tag_check (enum LTO_tags actual, enum LTO_tags expected)
973 {
974 if (actual != expected)
975 internal_error ("bytecode stream: expected tag %s instead of %s",
976 lto_tag_name (expected), lto_tag_name (actual));
977 }
978
979 /* Check that tag ACTUAL is in the range [TAG1, TAG2]. */
980 static inline void
lto_tag_check_range(enum LTO_tags actual,enum LTO_tags tag1,enum LTO_tags tag2)981 lto_tag_check_range (enum LTO_tags actual, enum LTO_tags tag1,
982 enum LTO_tags tag2)
983 {
984 if (actual < tag1 || actual > tag2)
985 internal_error ("bytecode stream: tag %s is not in the expected range "
986 "[%s, %s]",
987 lto_tag_name (actual),
988 lto_tag_name (tag1),
989 lto_tag_name (tag2));
990 }
991
992 /* Initialize an lto_out_decl_buffer ENCODER. */
993 static inline void
lto_init_tree_ref_encoder(struct lto_tree_ref_encoder * encoder,htab_hash hash_fn,htab_eq eq_fn)994 lto_init_tree_ref_encoder (struct lto_tree_ref_encoder *encoder,
995 htab_hash hash_fn, htab_eq eq_fn)
996 {
997 encoder->tree_hash_table = htab_create (37, hash_fn, eq_fn, free);
998 encoder->next_index = 0;
999 encoder->trees = NULL;
1000 }
1001
1002
1003 /* Destory an lto_tree_ref_encoder ENCODER by freeing its contents. The
1004 memory used by ENCODER is not freed by this function. */
1005 static inline void
lto_destroy_tree_ref_encoder(struct lto_tree_ref_encoder * encoder)1006 lto_destroy_tree_ref_encoder (struct lto_tree_ref_encoder *encoder)
1007 {
1008 /* Hash table may be delete already. */
1009 if (encoder->tree_hash_table)
1010 htab_delete (encoder->tree_hash_table);
1011 VEC_free (tree, heap, encoder->trees);
1012 }
1013
1014 /* Return the number of trees encoded in ENCODER. */
1015 static inline unsigned int
lto_tree_ref_encoder_size(struct lto_tree_ref_encoder * encoder)1016 lto_tree_ref_encoder_size (struct lto_tree_ref_encoder *encoder)
1017 {
1018 return VEC_length (tree, encoder->trees);
1019 }
1020
1021 /* Return the IDX-th tree in ENCODER. */
1022 static inline tree
lto_tree_ref_encoder_get_tree(struct lto_tree_ref_encoder * encoder,unsigned int idx)1023 lto_tree_ref_encoder_get_tree (struct lto_tree_ref_encoder *encoder,
1024 unsigned int idx)
1025 {
1026 return VEC_index (tree, encoder->trees, idx);
1027 }
1028
1029
1030 /* Return true if LABEL should be emitted in the global context. */
1031 static inline bool
emit_label_in_global_context_p(tree label)1032 emit_label_in_global_context_p (tree label)
1033 {
1034 return DECL_NONLOCAL (label) || FORCED_LABEL (label);
1035 }
1036
1037 DEFINE_DECL_STREAM_FUNCS (TYPE, type)
1038 DEFINE_DECL_STREAM_FUNCS (FIELD_DECL, field_decl)
1039 DEFINE_DECL_STREAM_FUNCS (FN_DECL, fn_decl)
1040 DEFINE_DECL_STREAM_FUNCS (VAR_DECL, var_decl)
1041 DEFINE_DECL_STREAM_FUNCS (TYPE_DECL, type_decl)
1042 DEFINE_DECL_STREAM_FUNCS (NAMESPACE_DECL, namespace_decl)
1043 DEFINE_DECL_STREAM_FUNCS (LABEL_DECL, label_decl)
1044
1045 #endif /* GCC_LTO_STREAMER_H */
1046