OSDN Git Service

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