OSDN Git Service

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