OSDN Git Service

* cgraph.h (struct ipa_replace_map): Add parm_num parameter.
[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_section_cgraph_opt_sum,
268   LTO_N_SECTION_TYPES           /* Must be last.  */
269 };
270
271 /* Indices to the various function, type and symbol streams. */
272 typedef enum
273 {
274   LTO_DECL_STREAM_TYPE = 0,             /* Must be first. */
275   LTO_DECL_STREAM_FIELD_DECL,
276   LTO_DECL_STREAM_FN_DECL,
277   LTO_DECL_STREAM_VAR_DECL,
278   LTO_DECL_STREAM_TYPE_DECL,
279   LTO_DECL_STREAM_NAMESPACE_DECL,
280   LTO_DECL_STREAM_LABEL_DECL,
281   LTO_N_DECL_STREAMS
282 } lto_decl_stream_e_t;
283
284 typedef enum ld_plugin_symbol_resolution ld_plugin_symbol_resolution_t;
285 DEF_VEC_I(ld_plugin_symbol_resolution_t);
286 DEF_VEC_ALLOC_I(ld_plugin_symbol_resolution_t, heap);
287
288
289 /* Macro to define convenience functions for type and decl streams
290    in lto_file_decl_data.  */
291 #define DEFINE_DECL_STREAM_FUNCS(UPPER_NAME, name) \
292 static inline tree \
293 lto_file_decl_data_get_ ## name (struct lto_file_decl_data *data, \
294                                  unsigned int idx) \
295 { \
296   struct lto_in_decl_state *state = data->current_decl_state; \
297   gcc_assert (idx < state->streams[LTO_DECL_STREAM_## UPPER_NAME].size); \
298   return state->streams[LTO_DECL_STREAM_## UPPER_NAME].trees[idx]; \
299 } \
300 \
301 static inline unsigned int \
302 lto_file_decl_data_num_ ## name ## s (struct lto_file_decl_data *data) \
303 { \
304   struct lto_in_decl_state *state = data->current_decl_state; \
305   return state->streams[LTO_DECL_STREAM_## UPPER_NAME].size; \
306 }
307
308
309 /* Return a char pointer to the start of a data stream for an lto pass
310    or function.  The first parameter is the file data that contains
311    the information.  The second parameter is the type of information
312    to be obtained.  The third parameter is the name of the function
313    and is only used when finding a function body; otherwise it is
314    NULL.  The fourth parameter is the length of the data returned.  */
315 typedef const char* (lto_get_section_data_f) (struct lto_file_decl_data *,
316                                               enum lto_section_type,
317                                               const char *,
318                                               size_t *);
319
320 /* Return the data found from the above call.  The first three
321    parameters are the same as above.  The fourth parameter is the data
322    itself and the fifth is the lenght of the data. */
323 typedef void (lto_free_section_data_f) (struct lto_file_decl_data *,
324                                         enum lto_section_type,
325                                         const char *,
326                                         const char *,
327                                         size_t);
328
329 /* Cache of pickled nodes.  Used to avoid writing the same node more
330    than once.  The first time a tree node is streamed out, it is
331    entered in this cache.  Subsequent references to the same node are
332    resolved by looking it up in this cache.
333
334    This is used in two ways:
335
336    - On the writing side, the first time T is added to STREAMER_CACHE,
337      a new reference index is created for T and T is emitted on the
338      stream.  If T needs to be emitted again to the stream, instead of
339      pickling it again, the reference index is emitted.
340
341    - On the reading side, the first time T is read from the stream, it
342      is reconstructed in memory and a new reference index created for
343      T.  The reconstructed T is inserted in some array so that when
344      the reference index for T is found in the input stream, it can be
345      used to look up into the array to get the reconstructed T.  */
346 struct lto_streamer_cache_d
347 {
348   /* The mapping between tree nodes and slots into the nodes array.  */
349   htab_t node_map;
350
351   /* Node map to store entries into.  */
352   alloc_pool node_map_entries;
353
354   /* Next available slot in the nodes and offsets arrays.  */
355   unsigned next_slot;
356
357   /* The nodes pickled so far.  */
358   VEC(tree,heap) *nodes;
359
360   /* Offset into the stream where the nodes have been written.  */
361   VEC(unsigned,heap) *offsets;
362 };
363
364
365 /* Structure used as buffer for reading an LTO file.  */
366 struct lto_input_block
367 {
368   const char *data;
369   unsigned int p;
370   unsigned int len;
371 };
372
373 #define LTO_INIT_INPUT_BLOCK(BASE,D,P,L)   \
374   do {                                     \
375     BASE.data = D;                         \
376     BASE.p = P;                            \
377     BASE.len = L;                          \
378   } while (0)
379
380 #define LTO_INIT_INPUT_BLOCK_PTR(BASE,D,P,L) \
381   do {                                       \
382     BASE->data = D;                          \
383     BASE->p = P;                             \
384     BASE->len = L;                           \
385   } while (0)
386
387
388 /* The is the first part of the record for a function or constructor
389    in the .o file.  */
390 struct lto_header
391 {
392   int16_t major_version;
393   int16_t minor_version;
394   enum lto_section_type section_type;
395 };
396
397 /* The header for a function body.  */
398 struct lto_function_header
399 {
400   /* The header for all types of sections. */
401   struct lto_header lto_header;
402
403   /* Number of labels with names.  */
404   int32_t num_named_labels;
405
406   /* Number of labels without names.  */
407   int32_t num_unnamed_labels;
408
409   /* Size compressed or 0 if not compressed.  */
410   int32_t compressed_size;
411
412   /* Size of names for named labels.  */
413   int32_t named_label_size;
414
415   /* Size of the cfg.  */
416   int32_t cfg_size;
417
418   /* Size of main gimple body of function.  */
419   int32_t main_size;
420
421   /* Size of the string table.  */
422   int32_t string_size;
423 };
424
425
426 /* Structure describing a symbol section.  */
427 struct lto_decl_header
428 {
429   /* The header for all types of sections. */
430   struct lto_header lto_header;
431
432   /* Size of region for decl state. */
433   int32_t decl_state_size;
434
435   /* Number of nodes in globals stream.  */
436   int32_t num_nodes;
437
438   /* Size of region for expressions, decls, types, etc. */
439   int32_t main_size;
440
441   /* Size of the string table.  */
442   int32_t string_size;
443 };
444
445
446 /* Statistics gathered during LTO, WPA and LTRANS.  */
447 struct lto_stats_d
448 {
449   unsigned HOST_WIDE_INT num_input_cgraph_nodes;
450   unsigned HOST_WIDE_INT num_output_cgraph_nodes;
451   unsigned HOST_WIDE_INT num_input_files;
452   unsigned HOST_WIDE_INT num_output_files;
453   unsigned HOST_WIDE_INT num_cgraph_partitions;
454   unsigned HOST_WIDE_INT section_size[LTO_N_SECTION_TYPES];
455   unsigned HOST_WIDE_INT num_function_bodies;
456   unsigned HOST_WIDE_INT num_trees[NUM_TREE_CODES];
457   unsigned HOST_WIDE_INT num_output_il_bytes;
458   unsigned HOST_WIDE_INT num_compressed_il_bytes;
459   unsigned HOST_WIDE_INT num_input_il_bytes;
460   unsigned HOST_WIDE_INT num_uncompressed_il_bytes;
461 };
462
463 /* Encoder data structure used to stream callgraph nodes.  */
464 struct lto_cgraph_encoder_d
465 {
466   /* Map nodes to reference number. */
467   struct pointer_map_t *map;
468
469   /* Map reference number to node. */
470   VEC(cgraph_node_ptr,heap) *nodes;
471
472   /* Map of nodes where we want to output body.  */
473   struct pointer_set_t *body;
474 };
475
476 typedef struct lto_cgraph_encoder_d *lto_cgraph_encoder_t;
477
478 /* Return number of encoded nodes in ENCODER.  */
479
480 static inline int
481 lto_cgraph_encoder_size (lto_cgraph_encoder_t encoder)
482 {
483   return VEC_length (cgraph_node_ptr, encoder->nodes);
484 }
485
486
487 /* Encoder data structure used to stream callgraph nodes.  */
488 struct lto_varpool_encoder_d
489 {
490   /* Map nodes to reference number. */
491   struct pointer_map_t *map;
492
493   /* Map reference number to node. */
494   VEC(varpool_node_ptr,heap) *nodes;
495
496   /* Map of nodes where we want to output initializer.  */
497   struct pointer_set_t *initializer;
498 };
499 typedef struct lto_varpool_encoder_d *lto_varpool_encoder_t;
500
501 /* Mapping from indices to trees.  */
502 struct GTY(()) lto_tree_ref_table
503 {
504   /* Array of referenced trees . */
505   tree * GTY((length ("%h.size"))) trees;
506
507   /* Size of array. */
508   unsigned int size;
509 };
510
511
512 /* Mapping between trees and slots in an array.  */
513 struct lto_decl_slot
514 {
515   tree t;
516   int slot_num;
517 };
518
519
520 /* The lto_tree_ref_encoder struct is used to encode trees into indices. */
521
522 struct lto_tree_ref_encoder
523 {
524   htab_t tree_hash_table;       /* Maps pointers to indices. */
525   unsigned int next_index;      /* Next available index. */
526   VEC(tree,heap) *trees;        /* Maps indices to pointers. */
527 };
528
529
530 /* Structure to hold states of input scope.  */
531 struct GTY(()) lto_in_decl_state
532 {
533   /* Array of lto_in_decl_buffers to store type and decls streams. */
534   struct lto_tree_ref_table streams[LTO_N_DECL_STREAMS];
535
536   /* If this in-decl state is associated with a function. FN_DECL
537      point to the FUNCTION_DECL. */
538   tree fn_decl;
539 };
540
541 typedef struct lto_in_decl_state *lto_in_decl_state_ptr;
542
543
544 /* The structure that holds all of the vectors of global types,
545    decls and cgraph nodes used in the serialization of this file.  */
546 struct lto_out_decl_state
547 {
548   /* The buffers contain the sets of decls of various kinds and types we have
549      seen so far and the indexes assigned to them.  */
550   struct lto_tree_ref_encoder streams[LTO_N_DECL_STREAMS];
551
552   /* Encoder for cgraph nodes.  */
553   lto_cgraph_encoder_t cgraph_node_encoder;
554
555   /* Encoder for varpool nodes.  */
556   lto_varpool_encoder_t varpool_node_encoder;
557
558   /* If this out-decl state belongs to a function, fn_decl points to that
559      function.  Otherwise, it is NULL. */
560   tree fn_decl;
561 };
562
563 typedef struct lto_out_decl_state *lto_out_decl_state_ptr;
564
565 DEF_VEC_P(lto_out_decl_state_ptr);
566 DEF_VEC_ALLOC_P(lto_out_decl_state_ptr, heap);
567
568 /* One of these is allocated for each object file that being compiled
569    by lto.  This structure contains the tables that are needed by the
570    serialized functions and ipa passes to connect themselves to the
571    global types and decls as they are reconstituted.  */
572 struct GTY(()) lto_file_decl_data
573 {
574   /* Decl state currently used. */
575   struct lto_in_decl_state *current_decl_state;
576
577   /* Decl state corresponding to regions outside of any functions
578      in the compilation unit. */
579   struct lto_in_decl_state *global_decl_state;
580
581   /* Table of cgraph nodes present in this file.  */
582   lto_cgraph_encoder_t GTY((skip)) cgraph_node_encoder;
583
584   /* Table of varpool nodes present in this file.  */
585   lto_varpool_encoder_t GTY((skip)) varpool_node_encoder;
586
587   /* Hash table maps lto-related section names to location in file.  */
588   htab_t GTY((param_is (struct lto_in_decl_state))) function_decl_states;
589
590   /* The .o file that these offsets relate to.  */
591   const char *GTY((skip)) file_name;
592
593   /* Hash table maps lto-related section names to location in file.  */
594   htab_t GTY((skip)) section_hash_table;
595
596   /* Hash new name of renamed global declaration to its original name.  */
597   htab_t GTY((skip)) renaming_hash_table;
598 };
599
600 struct lto_char_ptr_base
601 {
602   char *ptr;
603 };
604
605 /* An incore byte stream to buffer the various parts of the function.
606    The entire structure should be zeroed when created.  The record
607    consists of a set of blocks.  The first sizeof (ptr) bytes are used
608    as a chain, and the rest store the bytes to be written.  */
609 struct lto_output_stream
610 {
611   /* The pointer to the first block in the stream.  */
612   struct lto_char_ptr_base * first_block;
613
614   /* The pointer to the last and current block in the stream.  */
615   struct lto_char_ptr_base * current_block;
616
617   /* The pointer to where the next char should be written.  */
618   char * current_pointer;
619
620   /* The number of characters left in the current block.  */
621   unsigned int left_in_block;
622
623   /* The block size of the last block allocated.  */
624   unsigned int block_size;
625
626   /* The total number of characters written.  */
627   unsigned int total_size;
628 };
629
630 /* The is the first part of the record in an LTO file for many of the
631    IPA passes.  */
632 struct lto_simple_header
633 {
634   /* The header for all types of sections. */
635   struct lto_header lto_header;
636
637   /* Size of main gimple body of function.  */
638   int32_t main_size;
639
640   /* Size of main stream when compressed.  */
641   int32_t compressed_size;
642 };
643
644 /* A simple output block.  This can be used for simple IPA passes that
645    do not need more than one stream.  */
646 struct lto_simple_output_block
647 {
648   enum lto_section_type section_type;
649   struct lto_out_decl_state *decl_state;
650
651   /* The stream that the main tree codes are written to.  */
652   struct lto_output_stream *main_stream;
653 };
654
655 /* Data structure holding all the data and descriptors used when writing
656    an LTO file.  */
657 struct output_block
658 {
659   enum lto_section_type section_type;
660   struct lto_out_decl_state *decl_state;
661
662   /* The stream that the main tree codes are written to.  */
663   struct lto_output_stream *main_stream;
664
665   /* The stream that contains the string table.  */
666   struct lto_output_stream *string_stream;
667
668   /* The stream that contains the cfg.  */
669   struct lto_output_stream *cfg_stream;
670
671   /* The hash table that contains the set of strings we have seen so
672      far and the indexes assigned to them.  */
673   htab_t string_hash_table;
674
675   /* The current cgraph_node that we are currently serializing.  Null
676      if we are serializing something else.  */
677   struct cgraph_node *cgraph_node;
678
679   /* These are the last file and line that were seen in the stream.
680      If the current node differs from these, it needs to insert
681      something into the stream and fix these up.  */
682   const char *current_file;
683   int current_line;
684   int current_col;
685
686   /* True if writing globals and types.  */
687   bool global;
688
689   /* Cache of nodes written in this section.  */
690   struct lto_streamer_cache_d *writer_cache;
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 lto_streamer_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 unsigned char lto_input_1_unsigned (struct lto_input_block *);
747 extern unsigned HOST_WIDE_INT lto_input_uleb128 (struct lto_input_block *);
748 extern unsigned HOST_WIDEST_INT lto_input_widest_uint_uleb128 (
749                                                 struct lto_input_block *);
750 extern HOST_WIDE_INT lto_input_sleb128 (struct lto_input_block *);
751 extern htab_t lto_create_renaming_table (void);
752 extern void lto_record_renamed_decl (struct lto_file_decl_data *,
753                                      const char *, const char *);
754 extern const char *lto_get_decl_name_mapping (struct lto_file_decl_data *,
755                                               const char *);
756 extern struct lto_in_decl_state *lto_new_in_decl_state (void);
757 extern void lto_delete_in_decl_state (struct lto_in_decl_state *);
758 extern hashval_t lto_hash_in_decl_state (const void *);
759 extern int lto_eq_in_decl_state (const void *, const void *);
760 extern struct lto_in_decl_state *lto_get_function_in_decl_state (
761                                       struct lto_file_decl_data *, tree);
762
763 /* In lto-section-out.c  */
764 extern hashval_t lto_hash_decl_slot_node (const void *);
765 extern int lto_eq_decl_slot_node (const void *, const void *);
766 extern hashval_t lto_hash_type_slot_node (const void *);
767 extern int lto_eq_type_slot_node (const void *, const void *);
768 extern void lto_begin_section (const char *, bool);
769 extern void lto_end_section (void);
770 extern void lto_write_stream (struct lto_output_stream *);
771 extern void lto_output_1_stream (struct lto_output_stream *, char);
772 extern void lto_output_data_stream (struct lto_output_stream *, const void *,
773                                     size_t);
774 extern void lto_output_uleb128_stream (struct lto_output_stream *,
775                                        unsigned HOST_WIDE_INT);
776 extern void lto_output_widest_uint_uleb128_stream (struct lto_output_stream *,
777                                                    unsigned HOST_WIDEST_INT);
778 extern void lto_output_sleb128_stream (struct lto_output_stream *,
779                                        HOST_WIDE_INT);
780 extern bool lto_output_decl_index (struct lto_output_stream *,
781                             struct lto_tree_ref_encoder *,
782                             tree, unsigned int *);
783 extern void lto_output_field_decl_index (struct lto_out_decl_state *,
784                                   struct lto_output_stream *, tree);
785 extern void lto_output_fn_decl_index (struct lto_out_decl_state *,
786                                struct lto_output_stream *, tree);
787 extern void lto_output_namespace_decl_index (struct lto_out_decl_state *,
788                                       struct lto_output_stream *, tree);
789 extern void lto_output_var_decl_index (struct lto_out_decl_state *,
790                                 struct lto_output_stream *, tree);
791 extern void lto_output_type_decl_index (struct lto_out_decl_state *,
792                                  struct lto_output_stream *, tree);
793 extern void lto_output_type_ref_index (struct lto_out_decl_state *,
794                                 struct lto_output_stream *, tree);
795 extern struct lto_simple_output_block *lto_create_simple_output_block (
796                                 enum lto_section_type);
797 extern void lto_destroy_simple_output_block (struct lto_simple_output_block *);
798 extern struct lto_out_decl_state *lto_new_out_decl_state (void);
799 extern void lto_delete_out_decl_state (struct lto_out_decl_state *);
800 extern struct lto_out_decl_state *lto_get_out_decl_state (void);
801 extern void lto_push_out_decl_state (struct lto_out_decl_state *);
802 extern struct lto_out_decl_state *lto_pop_out_decl_state (void);
803 extern void lto_record_function_out_decl_state (tree,
804                                                 struct lto_out_decl_state *);
805
806
807 /* In lto-streamer.c.  */
808 extern const char *lto_tag_name (enum LTO_tags);
809 extern bitmap lto_bitmap_alloc (void);
810 extern void lto_bitmap_free (bitmap);
811 extern char *lto_get_section_name (int, const char *);
812 extern void print_lto_report (void);
813 extern struct bitpack_d *bitpack_create (void);
814 extern void bitpack_delete (struct bitpack_d *);
815 extern void bp_pack_value (struct bitpack_d *, bitpack_word_t, unsigned);
816 extern bitpack_word_t bp_unpack_value (struct bitpack_d *, unsigned);
817 extern bool lto_streamer_cache_insert (struct lto_streamer_cache_d *, tree,
818                                        int *, unsigned *);
819 extern bool lto_streamer_cache_insert_at (struct lto_streamer_cache_d *, tree,
820                                           int);
821 extern bool lto_streamer_cache_lookup (struct lto_streamer_cache_d *, tree,
822                                        int *);
823 extern tree lto_streamer_cache_get (struct lto_streamer_cache_d *, int);
824 extern struct lto_streamer_cache_d *lto_streamer_cache_create (void);
825 extern void lto_streamer_cache_delete (struct lto_streamer_cache_d *);
826 extern void lto_streamer_init (void);
827 extern bool gate_lto_out (void);
828 #ifdef LTO_STREAMER_DEBUG
829 extern void lto_orig_address_map (tree, intptr_t);
830 extern intptr_t lto_orig_address_get (tree);
831 extern void lto_orig_address_remove (tree);
832 #endif
833 extern void lto_check_version (int, int);
834
835
836 /* In lto-streamer-in.c */
837 extern void lto_input_cgraph (struct lto_file_decl_data *, const char *);
838 extern void lto_init_reader (void);
839 extern tree lto_input_tree (struct lto_input_block *, struct data_in *);
840 extern void lto_input_function_body (struct lto_file_decl_data *, tree,
841                                      const char *);
842 extern void lto_input_constructors_and_inits (struct lto_file_decl_data *,
843                                               const char *);
844 extern struct bitpack_d *lto_input_bitpack (struct lto_input_block *);
845 extern void lto_init_reader (void);
846 extern struct data_in *lto_data_in_create (struct lto_file_decl_data *,
847                                     const char *, unsigned,
848                                     VEC(ld_plugin_symbol_resolution_t,heap) *);
849 extern void lto_data_in_delete (struct data_in *);
850
851
852 /* In lto-streamer-out.c  */
853 extern void lto_register_decl_definition (tree, struct lto_file_decl_data *);
854 extern struct output_block *create_output_block (enum lto_section_type);
855 extern void destroy_output_block (struct output_block *);
856 extern void lto_output_tree (struct output_block *, tree, bool);
857 extern void lto_output_bitpack (struct lto_output_stream *, struct bitpack_d *);
858 extern void produce_asm (struct output_block *ob, tree fn);
859
860
861 /* In lto-cgraph.c  */
862 struct cgraph_node *lto_cgraph_encoder_deref (lto_cgraph_encoder_t, int);
863 int lto_cgraph_encoder_lookup (lto_cgraph_encoder_t, struct cgraph_node *);
864 lto_cgraph_encoder_t lto_cgraph_encoder_new (void);
865 int lto_cgraph_encoder_encode (lto_cgraph_encoder_t, struct cgraph_node *);
866 void lto_cgraph_encoder_delete (lto_cgraph_encoder_t);
867 bool lto_cgraph_encoder_encode_body_p (lto_cgraph_encoder_t,
868                                        struct cgraph_node *);
869
870 bool lto_varpool_encoder_encode_body_p (lto_varpool_encoder_t,
871                                         struct varpool_node *);
872 struct varpool_node *lto_varpool_encoder_deref (lto_varpool_encoder_t, int);
873 int lto_varpool_encoder_lookup (lto_varpool_encoder_t, struct varpool_node *);
874 lto_varpool_encoder_t lto_varpool_encoder_new (void);
875 int lto_varpool_encoder_encode (lto_varpool_encoder_t, struct varpool_node *);
876 void lto_varpool_encoder_delete (lto_varpool_encoder_t);
877 bool lto_varpool_encoder_encode_initializer_p (lto_varpool_encoder_t,
878                                                struct varpool_node *);
879 void output_cgraph (cgraph_node_set, varpool_node_set);
880 void input_cgraph (void);
881 bool referenced_from_other_partition_p (struct ipa_ref_list *,
882                                         cgraph_node_set,
883                                         varpool_node_set vset);
884 bool reachable_from_other_partition_p (struct cgraph_node *,
885                                        cgraph_node_set);
886 bool referenced_from_this_partition_p (struct ipa_ref_list *,
887                                         cgraph_node_set,
888                                         varpool_node_set vset);
889 bool reachable_from_this_partition_p (struct cgraph_node *,
890                                        cgraph_node_set);
891 void compute_ltrans_boundary (struct lto_out_decl_state *state,
892                               cgraph_node_set, varpool_node_set);
893
894
895 /* In lto-symtab.c.  */
896 extern void lto_symtab_register_decl (tree, ld_plugin_symbol_resolution_t,
897                                       struct lto_file_decl_data *);
898 extern void lto_symtab_merge_decls (void);
899 extern void lto_symtab_merge_cgraph_nodes (void);
900 extern tree lto_symtab_prevailing_decl (tree decl);
901 extern enum ld_plugin_symbol_resolution lto_symtab_get_resolution (tree decl);
902 extern void lto_symtab_free (void);
903
904
905 /* In lto-opts.c.  */
906 extern void lto_register_user_option (size_t, const char *, int, int);
907 extern void lto_read_file_options (struct lto_file_decl_data *);
908 extern void lto_write_options (void);
909 extern void lto_reissue_options (void);
910 void lto_clear_user_options (void);
911 void lto_clear_file_options (void);
912
913
914 /* In lto-wpa-fixup.c  */
915 void lto_mark_nothrow_fndecl (tree);
916 void lto_fixup_nothrow_decls (void);
917
918
919 /* Statistics gathered during LTO, WPA and LTRANS.  */
920 extern struct lto_stats_d lto_stats;
921
922 /* Section names corresponding to the values of enum lto_section_type.  */
923 extern const char *lto_section_name[];
924
925 /* Holds all the out decl states of functions output so far in the
926    current output file.  */
927 extern VEC(lto_out_decl_state_ptr, heap) *lto_function_decl_states;
928
929 /* Return true if LTO tag TAG corresponds to a tree code.  */
930 static inline bool
931 lto_tag_is_tree_code_p (enum LTO_tags tag)
932 {
933   return tag > LTO_null && (unsigned) tag <= NUM_TREE_CODES;
934 }
935
936
937 /* Return true if LTO tag TAG corresponds to a gimple code.  */
938 static inline bool
939 lto_tag_is_gimple_code_p (enum LTO_tags tag)
940 {
941   return (unsigned) tag >= NUM_TREE_CODES + 1
942          && (unsigned) tag < 1 + NUM_TREE_CODES + LAST_AND_UNUSED_GIMPLE_CODE;
943 }
944
945
946 /* Return the LTO tag corresponding to gimple code CODE.  See enum
947    LTO_tags for details on the conversion.  */
948 static inline enum LTO_tags
949 lto_gimple_code_to_tag (enum gimple_code code)
950 {
951   return (enum LTO_tags) ((unsigned) code + NUM_TREE_CODES + 1);
952 }
953
954
955 /* Return the GIMPLE code corresponding to TAG.  See enum LTO_tags for
956    details on the conversion.  */
957 static inline enum gimple_code
958 lto_tag_to_gimple_code (enum LTO_tags tag)
959 {
960   gcc_assert (lto_tag_is_gimple_code_p (tag));
961   return (enum gimple_code) ((unsigned) tag - NUM_TREE_CODES - 1);
962 }
963
964
965 /* Return the LTO tag corresponding to tree code CODE.  See enum
966    LTO_tags for details on the conversion.  */
967 static inline enum LTO_tags
968 lto_tree_code_to_tag (enum tree_code code)
969 {
970   return (enum LTO_tags) ((unsigned) code + 1);
971 }
972
973
974 /* Return the tree code corresponding to TAG.  See enum LTO_tags for
975    details on the conversion.  */
976 static inline enum tree_code
977 lto_tag_to_tree_code (enum LTO_tags tag)
978 {
979   gcc_assert (lto_tag_is_tree_code_p (tag));
980   return (enum tree_code) ((unsigned) tag - 1);
981 }
982
983 /* Initialize an lto_out_decl_buffer ENCODER.  */
984 static inline void
985 lto_init_tree_ref_encoder (struct lto_tree_ref_encoder *encoder,
986                            htab_hash hash_fn, htab_eq eq_fn)
987 {
988   encoder->tree_hash_table = htab_create (37, hash_fn, eq_fn, free);
989   encoder->next_index = 0;
990   encoder->trees = NULL;
991 }
992
993
994 /* Destory an lto_tree_ref_encoder ENCODER by freeing its contents.  The
995    memory used by ENCODER is not freed by this function.  */
996 static inline void
997 lto_destroy_tree_ref_encoder (struct lto_tree_ref_encoder *encoder)
998 {
999   /* Hash table may be delete already.  */
1000   if (encoder->tree_hash_table)
1001     htab_delete (encoder->tree_hash_table);
1002   VEC_free (tree, heap, encoder->trees);
1003 }
1004
1005 /* Return the number of trees encoded in ENCODER. */
1006 static inline unsigned int
1007 lto_tree_ref_encoder_size (struct lto_tree_ref_encoder *encoder)
1008 {
1009   return VEC_length (tree, encoder->trees);
1010 }
1011
1012 /* Return the IDX-th tree in ENCODER. */
1013 static inline tree
1014 lto_tree_ref_encoder_get_tree (struct lto_tree_ref_encoder *encoder,
1015                                unsigned int idx)
1016 {
1017   return VEC_index (tree, encoder->trees, idx);
1018 }
1019
1020
1021 /* Return true if LABEL should be emitted in the global context.  */
1022 static inline bool
1023 emit_label_in_global_context_p (tree label)
1024 {
1025   return DECL_NONLOCAL (label) || FORCED_LABEL (label);
1026 }
1027
1028 /* Return true if tree node EXPR should be streamed as a builtin.  For
1029    these nodes, we just emit the class and function code.  */
1030 static inline bool
1031 lto_stream_as_builtin_p (tree expr)
1032 {
1033   return (TREE_CODE (expr) == FUNCTION_DECL
1034           && DECL_IS_BUILTIN (expr)
1035           && (DECL_BUILT_IN_CLASS (expr) == BUILT_IN_NORMAL
1036               || DECL_BUILT_IN_CLASS (expr) == BUILT_IN_MD));
1037 }
1038
1039 /* Return true if EXPR is a tree node that can be written to disk.  */
1040 static inline bool
1041 lto_is_streamable (tree expr)
1042 {
1043   enum tree_code code = TREE_CODE (expr);
1044
1045   /* Notice that we reject SSA_NAMEs as well.  We only emit the SSA
1046      name version in lto_output_tree_ref (see output_ssa_names).  */
1047   return !is_lang_specific (expr)
1048          && code != SSA_NAME
1049          && code != CALL_EXPR
1050          && code != LANG_TYPE
1051          && code != MODIFY_EXPR
1052          && code != INIT_EXPR
1053          && code != TARGET_EXPR
1054          && code != BIND_EXPR
1055          && code != WITH_CLEANUP_EXPR
1056          && code != STATEMENT_LIST
1057          && (code == CASE_LABEL_EXPR
1058              || code == DECL_EXPR
1059              || TREE_CODE_CLASS (code) != tcc_statement);
1060 }
1061
1062 DEFINE_DECL_STREAM_FUNCS (TYPE, type)
1063 DEFINE_DECL_STREAM_FUNCS (FIELD_DECL, field_decl)
1064 DEFINE_DECL_STREAM_FUNCS (FN_DECL, fn_decl)
1065 DEFINE_DECL_STREAM_FUNCS (VAR_DECL, var_decl)
1066 DEFINE_DECL_STREAM_FUNCS (TYPE_DECL, type_decl)
1067 DEFINE_DECL_STREAM_FUNCS (NAMESPACE_DECL, namespace_decl)
1068 DEFINE_DECL_STREAM_FUNCS (LABEL_DECL, label_decl)
1069
1070 #endif /* GCC_LTO_STREAMER_H  */