Merge branch 'vendor/GCC50' - gcc 5.0 snapshot 1 FEB 2015
[dragonfly.git] / contrib / gcc-5.0 / 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-2015 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 "hash-table.h"
28 #include "hash-map.h"
29 #include "target.h"
30 #include "vec.h"
31 #include "alloc-pool.h"
32 #include "gcov-io.h"
33 #include "diagnostic.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 #define LTO_major_version 4
137 #define LTO_minor_version 0
138
139 typedef unsigned char   lto_decl_flags_t;
140
141
142 /* Tags representing the various IL objects written to the bytecode file
143    (GIMPLE statements, basic blocks, EH regions, tree nodes, etc).
144
145    NOTE, when adding new LTO tags, also update lto_tag_name.  */
146 enum LTO_tags
147 {
148   LTO_null = 0,
149
150   /* Special for streamer.  Reference to previously-streamed node.  */
151   LTO_tree_pickle_reference,
152
153   /* Reserve enough entries to fit all the tree and gimple codes handled
154      by the streamer.  This guarantees that:
155
156      1- Given a tree code C:
157                 enum LTO_tags tag == C + 1
158
159      2- Given a gimple code C:
160                 enum LTO_tags tag == C + NUM_TREE_CODES + 1
161
162      Conversely, to map between LTO tags and tree/gimple codes, the
163      reverse operation must be applied.  */
164   LTO_bb0 = 1 + MAX_TREE_CODES + LAST_AND_UNUSED_GIMPLE_CODE,
165   LTO_bb1,
166
167   /* EH region holding the previous statement.  */
168   LTO_eh_region,
169
170   /* An MD or NORMAL builtin.  Only the code and class are streamed out.  */
171   LTO_builtin_decl,
172
173   /* Shared INTEGER_CST node.  */
174   LTO_integer_cst,
175
176   /* Function body.  */
177   LTO_function,
178
179   /* EH table.  */
180   LTO_eh_table,
181
182   /* EH region types.  These mirror enum eh_region_type.  */
183   LTO_ert_cleanup,
184   LTO_ert_try,
185   LTO_ert_allowed_exceptions,
186   LTO_ert_must_not_throw,
187
188   /* EH landing pad.  */
189   LTO_eh_landing_pad,
190
191   /* EH try/catch node.  */
192   LTO_eh_catch,
193
194   /* Special for global streamer.  A blob of unnamed tree nodes.  */
195   LTO_tree_scc,
196
197   /* References to indexable tree nodes.  These objects are stored in
198      tables that are written separately from the function bodies that
199      reference them.  This way they can be instantiated even when the
200      referencing functions aren't (e.g., during WPA) and it also allows
201      functions to be copied from one file to another without having
202      to unpickle the body first (the references are location
203      independent).
204
205      NOTE, do not regroup these values as the grouping is exposed
206      in the range checks done in lto_input_tree.  */
207   LTO_field_decl_ref,                   /* Do not change.  */
208   LTO_function_decl_ref,
209   LTO_label_decl_ref,
210   LTO_namespace_decl_ref,
211   LTO_result_decl_ref,
212   LTO_ssa_name_ref,
213   LTO_type_decl_ref,
214   LTO_type_ref,
215   LTO_const_decl_ref,
216   LTO_imported_decl_ref,
217   LTO_translation_unit_decl_ref,
218   LTO_global_decl_ref,
219   LTO_namelist_decl_ref,                /* Do not change.  */
220
221   /* This tag must always be last.  */
222   LTO_NUM_TAGS
223 };
224
225
226 /* Set of section types that are in an LTO file.  This list will grow
227    as the number of IPA passes grows since each IPA pass will need its
228    own section type to store its summary information.
229
230    When adding a new section type, you must also extend the
231    LTO_SECTION_NAME array in lto-section-in.c.  */
232 enum lto_section_type
233 {
234   LTO_section_decls = 0,
235   LTO_section_function_body,
236   LTO_section_static_initializer,
237   LTO_section_symtab,
238   LTO_section_refs,
239   LTO_section_asm,
240   LTO_section_jump_functions,
241   LTO_section_ipa_pure_const,
242   LTO_section_ipa_reference,
243   LTO_section_ipa_profile,
244   LTO_section_symtab_nodes,
245   LTO_section_opts,
246   LTO_section_cgraph_opt_sum,
247   LTO_section_inline_summary,
248   LTO_section_ipcp_transform,
249   LTO_section_ipa_icf,
250   LTO_section_offload_table,
251   LTO_N_SECTION_TYPES           /* Must be last.  */
252 };
253
254 /* Indices to the various function, type and symbol streams. */
255 enum lto_decl_stream_e_t
256 {
257   LTO_DECL_STREAM_TYPE = 0,             /* Must be first. */
258   LTO_DECL_STREAM_FIELD_DECL,
259   LTO_DECL_STREAM_FN_DECL,
260   LTO_DECL_STREAM_VAR_DECL,
261   LTO_DECL_STREAM_TYPE_DECL,
262   LTO_DECL_STREAM_NAMESPACE_DECL,
263   LTO_DECL_STREAM_LABEL_DECL,
264   LTO_N_DECL_STREAMS
265 };
266
267 typedef enum ld_plugin_symbol_resolution ld_plugin_symbol_resolution_t;
268
269
270 /* Macro to define convenience functions for type and decl streams
271    in lto_file_decl_data.  */
272 #define DEFINE_DECL_STREAM_FUNCS(UPPER_NAME, name) \
273 static inline tree \
274 lto_file_decl_data_get_ ## name (struct lto_file_decl_data *data, \
275                                  unsigned int idx) \
276 { \
277   struct lto_in_decl_state *state = data->current_decl_state; \
278    return (*state->streams[LTO_DECL_STREAM_## UPPER_NAME])[idx]; \
279 } \
280 \
281 static inline unsigned int \
282 lto_file_decl_data_num_ ## name ## s (struct lto_file_decl_data *data) \
283 { \
284   struct lto_in_decl_state *state = data->current_decl_state; \
285   return vec_safe_length (state->streams[LTO_DECL_STREAM_## UPPER_NAME]); \
286 }
287
288
289 /* Return a char pointer to the start of a data stream for an lto pass
290    or function.  The first parameter is the file data that contains
291    the information.  The second parameter is the type of information
292    to be obtained.  The third parameter is the name of the function
293    and is only used when finding a function body; otherwise it is
294    NULL.  The fourth parameter is the length of the data returned.  */
295 typedef const char* (lto_get_section_data_f) (struct lto_file_decl_data *,
296                                               enum lto_section_type,
297                                               const char *,
298                                               size_t *);
299
300 /* Return the data found from the above call.  The first three
301    parameters are the same as above.  The fourth parameter is the data
302    itself and the fifth is the length of the data. */
303 typedef void (lto_free_section_data_f) (struct lto_file_decl_data *,
304                                         enum lto_section_type,
305                                         const char *,
306                                         const char *,
307                                         size_t);
308
309 /* Structure used as buffer for reading an LTO file.  */
310 class lto_input_block
311 {
312 public:
313   /* Special constructor for the string table, it abuses this to
314      do random access but use the uhwi decoder.  */
315   lto_input_block (const char *data_, unsigned int p_, unsigned int len_)
316       : data (data_), p (p_), len (len_) {}
317   lto_input_block (const char *data_, unsigned int len_)
318       : data (data_), p (0), len (len_) {}
319
320   const char *data;
321   unsigned int p;
322   unsigned int len;
323 };
324
325
326 /* The is the first part of the record for a function or constructor
327    in the .o file.  */
328 struct lto_header
329 {
330   int16_t major_version;
331   int16_t minor_version;
332 };
333
334 /* The is the first part of the record in an LTO file for many of the
335    IPA passes.  */
336 struct lto_simple_header : lto_header
337 {
338   /* Size of main gimple body of function.  */
339   int32_t main_size;
340 };
341
342 struct lto_simple_header_with_strings : lto_simple_header
343 {
344   /* Size of main gimple body of function.  */
345   int32_t main_size;
346
347   /* Size of the string table.  */
348   int32_t string_size;
349 };
350
351 /* The header for a function body.  */
352 struct lto_function_header : lto_simple_header_with_strings
353 {
354   /* Size of the cfg.  */
355   int32_t cfg_size;
356 };
357
358
359 /* Structure describing a symbol section.  */
360 struct lto_decl_header : lto_simple_header_with_strings
361 {
362   /* Size of region for decl state. */
363   int32_t decl_state_size;
364
365   /* Number of nodes in globals stream.  */
366   int32_t num_nodes;
367 };
368
369
370 /* Statistics gathered during LTO, WPA and LTRANS.  */
371 struct lto_stats_d
372 {
373   unsigned HOST_WIDE_INT num_input_cgraph_nodes;
374   unsigned HOST_WIDE_INT num_output_symtab_nodes;
375   unsigned HOST_WIDE_INT num_input_files;
376   unsigned HOST_WIDE_INT num_output_files;
377   unsigned HOST_WIDE_INT num_cgraph_partitions;
378   unsigned HOST_WIDE_INT section_size[LTO_N_SECTION_TYPES];
379   unsigned HOST_WIDE_INT num_function_bodies;
380   unsigned HOST_WIDE_INT num_trees[NUM_TREE_CODES];
381   unsigned HOST_WIDE_INT num_output_il_bytes;
382   unsigned HOST_WIDE_INT num_compressed_il_bytes;
383   unsigned HOST_WIDE_INT num_input_il_bytes;
384   unsigned HOST_WIDE_INT num_uncompressed_il_bytes;
385   unsigned HOST_WIDE_INT num_tree_bodies_output;
386   unsigned HOST_WIDE_INT num_pickle_refs_output;
387 };
388
389 /* Entry of LTO symtab encoder.  */
390 struct lto_encoder_entry
391 {
392   symtab_node *node;
393   /* Is the node in this partition (i.e. ltrans of this partition will
394      be responsible for outputting it)? */
395   unsigned int in_partition:1;
396   /* Do we encode body in this partition?  */
397   unsigned int body:1;
398   /* Do we encode initializer in this partition?
399      For example the readonly variable initializers are encoded to aid
400      constant folding even if they are not in the partition.  */
401   unsigned int initializer:1;
402 };
403
404
405 /* Encoder data structure used to stream callgraph nodes.  */
406 struct lto_symtab_encoder_d
407 {
408   vec<lto_encoder_entry> nodes;
409   hash_map<symtab_node *, size_t> *map;
410 };
411
412 typedef struct lto_symtab_encoder_d *lto_symtab_encoder_t;
413
414 /* Iterator structure for cgraph node sets.  */
415 struct lto_symtab_encoder_iterator
416 {
417   lto_symtab_encoder_t encoder;
418   unsigned index;
419 };
420
421
422
423 /* The lto_tree_ref_encoder struct is used to encode trees into indices. */
424
425 struct lto_tree_ref_encoder
426 {
427   hash_map<tree, unsigned> *tree_hash_table;    /* Maps pointers to indices. */
428   vec<tree> trees;                      /* Maps indices to pointers. */
429 };
430
431
432 /* Structure to hold states of input scope.  */
433 struct GTY((for_user)) lto_in_decl_state
434 {
435   /* Array of lto_in_decl_buffers to store type and decls streams. */
436   vec<tree, va_gc> *streams[LTO_N_DECL_STREAMS];
437
438   /* If this in-decl state is associated with a function. FN_DECL
439      point to the FUNCTION_DECL. */
440   tree fn_decl;
441 };
442
443 typedef struct lto_in_decl_state *lto_in_decl_state_ptr;
444
445 struct decl_state_hasher : ggc_hasher<lto_in_decl_state *>
446 {
447   static hashval_t
448   hash (lto_in_decl_state *s)
449   {
450     return htab_hash_pointer (s->fn_decl);
451   }
452
453   static bool
454   equal (lto_in_decl_state *a, lto_in_decl_state *b)
455   {
456     return a->fn_decl == b->fn_decl;
457   }
458 };
459
460 /* The structure that holds all of the vectors of global types,
461    decls and cgraph nodes used in the serialization of this file.  */
462 struct lto_out_decl_state
463 {
464   /* The buffers contain the sets of decls of various kinds and types we have
465      seen so far and the indexes assigned to them.  */
466   struct lto_tree_ref_encoder streams[LTO_N_DECL_STREAMS];
467
468   /* Encoder for cgraph nodes.  */
469   lto_symtab_encoder_t symtab_node_encoder;
470
471   /* If this out-decl state belongs to a function, fn_decl points to that
472      function.  Otherwise, it is NULL. */
473   tree fn_decl;
474 };
475
476 typedef struct lto_out_decl_state *lto_out_decl_state_ptr;
477
478
479 /* Compact representation of a index <-> resolution pair. Unpacked to an 
480    vector later. */
481 struct res_pair 
482 {
483   ld_plugin_symbol_resolution_t res;
484   unsigned index;
485 };
486
487
488 /* One of these is allocated for each object file that being compiled
489    by lto.  This structure contains the tables that are needed by the
490    serialized functions and ipa passes to connect themselves to the
491    global types and decls as they are reconstituted.  */
492 struct GTY(()) lto_file_decl_data
493 {
494   /* Decl state currently used. */
495   struct lto_in_decl_state *current_decl_state;
496
497   /* Decl state corresponding to regions outside of any functions
498      in the compilation unit. */
499   struct lto_in_decl_state *global_decl_state;
500
501   /* Table of cgraph nodes present in this file.  */
502   lto_symtab_encoder_t GTY((skip)) symtab_node_encoder;
503
504   /* Hash table maps lto-related section names to location in file.  */
505   hash_table<decl_state_hasher> *function_decl_states;
506
507   /* The .o file that these offsets relate to.  */
508   const char *GTY((skip)) file_name;
509
510   /* Hash table maps lto-related section names to location in file.  */
511   htab_t GTY((skip)) section_hash_table;
512
513   /* Hash new name of renamed global declaration to its original name.  */
514   htab_t GTY((skip)) renaming_hash_table;
515
516   /* Linked list used temporarily in reader */
517   struct lto_file_decl_data *next;
518
519   /* Sub ID for merged objects. */
520   unsigned HOST_WIDE_INT id;
521
522   /* Symbol resolutions for this file */
523   vec<res_pair>  GTY((skip)) respairs;
524   unsigned max_index;
525
526   struct gcov_ctr_summary GTY((skip)) profile_info;
527
528   /* Map assigning declarations their resolutions.  */
529   hash_map<tree, ld_plugin_symbol_resolution> * GTY((skip)) resolution_map;
530 };
531
532 typedef struct lto_file_decl_data *lto_file_decl_data_ptr;
533
534 struct lto_char_ptr_base
535 {
536   char *ptr;
537 };
538
539 /* An incore byte stream to buffer the various parts of the function.
540    The entire structure should be zeroed when created.  The record
541    consists of a set of blocks.  The first sizeof (ptr) bytes are used
542    as a chain, and the rest store the bytes to be written.  */
543 struct lto_output_stream
544 {
545   /* The pointer to the first block in the stream.  */
546   struct lto_char_ptr_base * first_block;
547
548   /* The pointer to the last and current block in the stream.  */
549   struct lto_char_ptr_base * current_block;
550
551   /* The pointer to where the next char should be written.  */
552   char * current_pointer;
553
554   /* The number of characters left in the current block.  */
555   unsigned int left_in_block;
556
557   /* The block size of the last block allocated.  */
558   unsigned int block_size;
559
560   /* The total number of characters written.  */
561   unsigned int total_size;
562 };
563
564 /* A simple output block.  This can be used for simple IPA passes that
565    do not need more than one stream.  */
566 struct lto_simple_output_block
567 {
568   enum lto_section_type section_type;
569   struct lto_out_decl_state *decl_state;
570
571   /* The stream that the main tree codes are written to.  */
572   struct lto_output_stream *main_stream;
573 };
574
575 /* String hashing.  */
576
577 struct string_slot
578 {
579   const char *s;
580   int len;
581   unsigned int slot_num;
582 };
583
584 /* Hashtable helpers.  */
585
586 struct string_slot_hasher : typed_noop_remove <string_slot>
587 {
588   typedef string_slot value_type;
589   typedef string_slot compare_type;
590   static inline hashval_t hash (const value_type *);
591   static inline bool equal (const value_type *, const compare_type *);
592 };
593
594 /* Returns a hash code for DS.  Adapted from libiberty's htab_hash_string
595    to support strings that may not end in '\0'.  */
596
597 inline hashval_t
598 string_slot_hasher::hash (const value_type *ds)
599 {
600   hashval_t r = ds->len;
601   int i;
602
603   for (i = 0; i < ds->len; i++)
604      r = r * 67 + (unsigned)ds->s[i] - 113;
605   return r;
606 }
607
608 /* Returns nonzero if DS1 and DS2 are equal.  */
609
610 inline bool
611 string_slot_hasher::equal (const value_type *ds1, const compare_type *ds2)
612 {
613   if (ds1->len == ds2->len)
614     return memcmp (ds1->s, ds2->s, ds1->len) == 0;
615
616   return 0;
617 }
618
619 /* Data structure holding all the data and descriptors used when writing
620    an LTO file.  */
621 struct output_block
622 {
623   enum lto_section_type section_type;
624   struct lto_out_decl_state *decl_state;
625
626   /* The stream that the main tree codes are written to.  */
627   struct lto_output_stream *main_stream;
628
629   /* The stream that contains the string table.  */
630   struct lto_output_stream *string_stream;
631
632   /* The stream that contains the cfg.  */
633   struct lto_output_stream *cfg_stream;
634
635   /* The hash table that contains the set of strings we have seen so
636      far and the indexes assigned to them.  */
637   hash_table<string_slot_hasher> *string_hash_table;
638
639   /* The current symbol that we are currently serializing.  Null
640      if we are serializing something else.  */
641   symtab_node *symbol;
642
643   /* These are the last file and line that were seen in the stream.
644      If the current node differs from these, it needs to insert
645      something into the stream and fix these up.  */
646   const char *current_file;
647   int current_line;
648   int current_col;
649
650   /* Cache of nodes written in this section.  */
651   struct streamer_tree_cache_d *writer_cache;
652
653   /* All data persistent across whole duration of output block
654      can go here.  */
655   struct obstack obstack;
656 };
657
658
659 /* Data and descriptors used when reading from an LTO file.  */
660 struct data_in
661 {
662   /* The global decls and types.  */
663   struct lto_file_decl_data *file_data;
664
665   /* The string table.  */
666   const char *strings;
667
668   /* The length of the string table.  */
669   unsigned int strings_len;
670
671   /* Maps each reference number to the resolution done by the linker. */
672   vec<ld_plugin_symbol_resolution_t> globals_resolution;
673
674   /* Cache of pickled nodes.  */
675   struct streamer_tree_cache_d *reader_cache;
676 };
677
678
679 /* In lto-section-in.c  */
680 extern struct lto_input_block * lto_create_simple_input_block (
681                                struct lto_file_decl_data *,
682                                enum lto_section_type, const char **, size_t *);
683 extern void
684 lto_destroy_simple_input_block (struct lto_file_decl_data *,
685                                 enum lto_section_type,
686                                 struct lto_input_block *, const char *, size_t);
687 extern void lto_set_in_hooks (struct lto_file_decl_data **,
688                               lto_get_section_data_f *,
689                               lto_free_section_data_f *);
690 extern struct lto_file_decl_data **lto_get_file_decl_data (void);
691 extern const char *lto_get_section_data (struct lto_file_decl_data *,
692                                          enum lto_section_type,
693                                          const char *, size_t *);
694 extern void lto_free_section_data (struct lto_file_decl_data *,
695                                    enum lto_section_type,
696                                    const char *, const char *, size_t);
697 extern htab_t lto_create_renaming_table (void);
698 extern void lto_record_renamed_decl (struct lto_file_decl_data *,
699                                      const char *, const char *);
700 extern const char *lto_get_decl_name_mapping (struct lto_file_decl_data *,
701                                               const char *);
702 extern struct lto_in_decl_state *lto_new_in_decl_state (void);
703 extern void lto_delete_in_decl_state (struct lto_in_decl_state *);
704 extern struct lto_in_decl_state *lto_get_function_in_decl_state (
705                                       struct lto_file_decl_data *, tree);
706 extern void lto_free_function_in_decl_state (struct lto_in_decl_state *);
707 extern void lto_free_function_in_decl_state_for_node (symtab_node *);
708 extern void lto_section_overrun (struct lto_input_block *) ATTRIBUTE_NORETURN;
709 extern void lto_value_range_error (const char *,
710                                    HOST_WIDE_INT, HOST_WIDE_INT,
711                                    HOST_WIDE_INT) ATTRIBUTE_NORETURN;
712
713 /* In lto-section-out.c  */
714 extern void lto_begin_section (const char *, bool);
715 extern void lto_end_section (void);
716 extern void lto_write_data (const void *, unsigned int);
717 extern void lto_write_stream (struct lto_output_stream *);
718 extern bool lto_output_decl_index (struct lto_output_stream *,
719                             struct lto_tree_ref_encoder *,
720                             tree, unsigned int *);
721 extern void lto_output_field_decl_index (struct lto_out_decl_state *,
722                                   struct lto_output_stream *, tree);
723 extern void lto_output_fn_decl_index (struct lto_out_decl_state *,
724                                struct lto_output_stream *, tree);
725 extern void lto_output_namespace_decl_index (struct lto_out_decl_state *,
726                                       struct lto_output_stream *, tree);
727 extern void lto_output_var_decl_index (struct lto_out_decl_state *,
728                                 struct lto_output_stream *, tree);
729 extern void lto_output_type_decl_index (struct lto_out_decl_state *,
730                                  struct lto_output_stream *, tree);
731 extern void lto_output_type_ref_index (struct lto_out_decl_state *,
732                                 struct lto_output_stream *, tree);
733 extern struct lto_simple_output_block *lto_create_simple_output_block (
734                                 enum lto_section_type);
735 extern void lto_destroy_simple_output_block (struct lto_simple_output_block *);
736 extern struct lto_out_decl_state *lto_new_out_decl_state (void);
737 extern void lto_delete_out_decl_state (struct lto_out_decl_state *);
738 extern struct lto_out_decl_state *lto_get_out_decl_state (void);
739 extern void lto_push_out_decl_state (struct lto_out_decl_state *);
740 extern struct lto_out_decl_state *lto_pop_out_decl_state (void);
741 extern void lto_record_function_out_decl_state (tree,
742                                                 struct lto_out_decl_state *);
743 extern void lto_append_block (struct lto_output_stream *);
744
745
746 /* In lto-streamer.c.  */
747
748 /* Set when streaming LTO for offloading compiler.  */
749 extern bool lto_stream_offload_p;
750
751 extern const char *lto_tag_name (enum LTO_tags);
752 extern bitmap lto_bitmap_alloc (void);
753 extern void lto_bitmap_free (bitmap);
754 extern char *lto_get_section_name (int, const char *, struct lto_file_decl_data *);
755 extern void print_lto_report (const char *);
756 extern void lto_streamer_init (void);
757 extern bool gate_lto_out (void);
758 #ifdef LTO_STREAMER_DEBUG
759 extern void lto_orig_address_map (tree, intptr_t);
760 extern intptr_t lto_orig_address_get (tree);
761 extern void lto_orig_address_remove (tree);
762 #endif
763 extern void lto_check_version (int, int);
764 extern void lto_streamer_hooks_init (void);
765
766 /* In lto-streamer-in.c */
767 extern void lto_input_cgraph (struct lto_file_decl_data *, const char *);
768 extern void lto_reader_init (void);
769 extern void lto_input_function_body (struct lto_file_decl_data *,
770                                      struct cgraph_node *,
771                                      const char *);
772 extern void lto_input_variable_constructor (struct lto_file_decl_data *,
773                                             struct varpool_node *,
774                                             const char *);
775 extern void lto_input_constructors_and_inits (struct lto_file_decl_data *,
776                                               const char *);
777 extern void lto_input_toplevel_asms (struct lto_file_decl_data *, int);
778 extern struct data_in *lto_data_in_create (struct lto_file_decl_data *,
779                                     const char *, unsigned,
780                                     vec<ld_plugin_symbol_resolution_t> );
781 extern void lto_data_in_delete (struct data_in *);
782 extern void lto_input_data_block (struct lto_input_block *, void *, size_t);
783 location_t lto_input_location (struct bitpack_d *, struct data_in *);
784 tree lto_input_tree_ref (struct lto_input_block *, struct data_in *,
785                          struct function *, enum LTO_tags);
786 void lto_tag_check_set (enum LTO_tags, int, ...);
787 void lto_init_eh (void);
788 hashval_t lto_input_scc (struct lto_input_block *, struct data_in *,
789                          unsigned *, unsigned *);
790 tree lto_input_tree_1 (struct lto_input_block *, struct data_in *,
791                        enum LTO_tags, hashval_t hash);
792 tree lto_input_tree (struct lto_input_block *, struct data_in *);
793
794
795 /* In lto-streamer-out.c  */
796 extern void lto_register_decl_definition (tree, struct lto_file_decl_data *);
797 extern struct output_block *create_output_block (enum lto_section_type);
798 extern void destroy_output_block (struct output_block *);
799 extern void lto_output_tree (struct output_block *, tree, bool, bool);
800 extern void lto_output_toplevel_asms (void);
801 extern void produce_asm (struct output_block *ob, tree fn);
802 extern void lto_output ();
803 extern void produce_asm_for_decls ();
804 void lto_output_decl_state_streams (struct output_block *,
805                                     struct lto_out_decl_state *);
806 void lto_output_decl_state_refs (struct output_block *,
807                                  struct lto_output_stream *,
808                                  struct lto_out_decl_state *);
809 void lto_output_location (struct output_block *, struct bitpack_d *, location_t);
810
811
812 /* In lto-cgraph.c  */
813 extern bool asm_nodes_output;
814 lto_symtab_encoder_t lto_symtab_encoder_new (bool);
815 int lto_symtab_encoder_encode (lto_symtab_encoder_t, symtab_node *);
816 void lto_symtab_encoder_delete (lto_symtab_encoder_t);
817 bool lto_symtab_encoder_delete_node (lto_symtab_encoder_t, symtab_node *);
818 bool lto_symtab_encoder_encode_body_p (lto_symtab_encoder_t,
819                                        struct cgraph_node *);
820 bool lto_symtab_encoder_in_partition_p (lto_symtab_encoder_t,
821                                         symtab_node *);
822 void lto_set_symtab_encoder_in_partition (lto_symtab_encoder_t,
823                                           symtab_node *);
824
825 bool lto_symtab_encoder_encode_initializer_p (lto_symtab_encoder_t,
826                                               varpool_node *);
827 void output_symtab (void);
828 void input_symtab (void);
829 void output_offload_tables (void);
830 void input_offload_tables (void);
831 bool referenced_from_other_partition_p (struct ipa_ref_list *,
832                                         lto_symtab_encoder_t);
833 bool reachable_from_other_partition_p (struct cgraph_node *,
834                                        lto_symtab_encoder_t);
835 bool referenced_from_this_partition_p (symtab_node *,
836                                         lto_symtab_encoder_t);
837 bool reachable_from_this_partition_p (struct cgraph_node *,
838                                       lto_symtab_encoder_t);
839 lto_symtab_encoder_t compute_ltrans_boundary (lto_symtab_encoder_t encoder);
840 void select_what_to_stream (void);
841
842 /* In options-save.c.  */
843 void cl_target_option_stream_out (struct output_block *, struct bitpack_d *,
844                                   struct cl_target_option *);
845
846 void cl_target_option_stream_in (struct data_in *,
847                                  struct bitpack_d *,
848                                  struct cl_target_option *);
849
850 void cl_optimization_stream_out (struct bitpack_d *, struct cl_optimization *);
851
852 void cl_optimization_stream_in (struct bitpack_d *, struct cl_optimization *);
853
854
855 /* In lto-symtab.c.  */
856 extern void lto_symtab_merge_decls (void);
857 extern void lto_symtab_merge_symbols (void);
858 extern tree lto_symtab_prevailing_decl (tree decl);
859
860
861 /* In lto-opts.c.  */
862 extern void lto_write_options (void);
863
864
865 /* Statistics gathered during LTO, WPA and LTRANS.  */
866 extern struct lto_stats_d lto_stats;
867
868 /* Section names corresponding to the values of enum lto_section_type.  */
869 extern const char *lto_section_name[];
870
871 /* Holds all the out decl states of functions output so far in the
872    current output file.  */
873 extern vec<lto_out_decl_state_ptr> lto_function_decl_states;
874
875 /* Return true if LTO tag TAG corresponds to a tree code.  */
876 static inline bool
877 lto_tag_is_tree_code_p (enum LTO_tags tag)
878 {
879   return tag > LTO_tree_pickle_reference && (unsigned) tag <= MAX_TREE_CODES;
880 }
881
882
883 /* Return true if LTO tag TAG corresponds to a gimple code.  */
884 static inline bool
885 lto_tag_is_gimple_code_p (enum LTO_tags tag)
886 {
887   return (unsigned) tag >= NUM_TREE_CODES + 2
888          && (unsigned) tag < 2 + NUM_TREE_CODES + LAST_AND_UNUSED_GIMPLE_CODE;
889 }
890
891
892 /* Return the LTO tag corresponding to gimple code CODE.  See enum
893    LTO_tags for details on the conversion.  */
894 static inline enum LTO_tags
895 lto_gimple_code_to_tag (enum gimple_code code)
896 {
897   return (enum LTO_tags) ((unsigned) code + NUM_TREE_CODES + 2);
898 }
899
900
901 /* Return the GIMPLE code corresponding to TAG.  See enum LTO_tags for
902    details on the conversion.  */
903 static inline enum gimple_code
904 lto_tag_to_gimple_code (enum LTO_tags tag)
905 {
906   gcc_assert (lto_tag_is_gimple_code_p (tag));
907   return (enum gimple_code) ((unsigned) tag - NUM_TREE_CODES - 2);
908 }
909
910
911 /* Return the LTO tag corresponding to tree code CODE.  See enum
912    LTO_tags for details on the conversion.  */
913 static inline enum LTO_tags
914 lto_tree_code_to_tag (enum tree_code code)
915 {
916   return (enum LTO_tags) ((unsigned) code + 2);
917 }
918
919
920 /* Return the tree code corresponding to TAG.  See enum LTO_tags for
921    details on the conversion.  */
922 static inline enum tree_code
923 lto_tag_to_tree_code (enum LTO_tags tag)
924 {
925   gcc_assert (lto_tag_is_tree_code_p (tag));
926   return (enum tree_code) ((unsigned) tag - 2);
927 }
928
929 /* Check that tag ACTUAL == EXPECTED.  */
930 static inline void
931 lto_tag_check (enum LTO_tags actual, enum LTO_tags expected)
932 {
933   if (actual != expected)
934     internal_error ("bytecode stream: expected tag %s instead of %s",
935                     lto_tag_name (expected), lto_tag_name (actual));
936 }
937
938 /* Check that tag ACTUAL is in the range [TAG1, TAG2].  */
939 static inline void
940 lto_tag_check_range (enum LTO_tags actual, enum LTO_tags tag1,
941                      enum LTO_tags tag2)
942 {
943   if (actual < tag1 || actual > tag2)
944     internal_error ("bytecode stream: tag %s is not in the expected range "
945                     "[%s, %s]",
946                     lto_tag_name (actual),
947                     lto_tag_name (tag1),
948                     lto_tag_name (tag2));
949 }
950
951 /* Initialize an lto_out_decl_buffer ENCODER.  */
952 static inline void
953 lto_init_tree_ref_encoder (struct lto_tree_ref_encoder *encoder)
954 {
955   encoder->tree_hash_table = new hash_map<tree, unsigned> (251);
956   encoder->trees.create (0);
957 }
958
959
960 /* Destroy an lto_tree_ref_encoder ENCODER by freeing its contents.  The
961    memory used by ENCODER is not freed by this function.  */
962 static inline void
963 lto_destroy_tree_ref_encoder (struct lto_tree_ref_encoder *encoder)
964 {
965   /* Hash table may be delete already.  */
966   delete encoder->tree_hash_table;
967   encoder->tree_hash_table = NULL;
968   encoder->trees.release ();
969 }
970
971 /* Return the number of trees encoded in ENCODER. */
972 static inline unsigned int
973 lto_tree_ref_encoder_size (struct lto_tree_ref_encoder *encoder)
974 {
975   return encoder->trees.length ();
976 }
977
978 /* Return the IDX-th tree in ENCODER. */
979 static inline tree
980 lto_tree_ref_encoder_get_tree (struct lto_tree_ref_encoder *encoder,
981                                unsigned int idx)
982 {
983   return encoder->trees[idx];
984 }
985
986 /* Return number of encoded nodes in ENCODER.  */
987 static inline int
988 lto_symtab_encoder_size (lto_symtab_encoder_t encoder)
989 {
990   return encoder->nodes.length ();
991 }
992
993 /* Value used to represent failure of lto_symtab_encoder_lookup.  */
994 #define LCC_NOT_FOUND   (-1)
995
996 /* Look up NODE in encoder.  Return NODE's reference if it has been encoded
997    or LCC_NOT_FOUND if it is not there.  */
998
999 static inline int
1000 lto_symtab_encoder_lookup (lto_symtab_encoder_t encoder,
1001                            symtab_node *node)
1002 {
1003   size_t *slot = encoder->map->get (node);
1004   return (slot && *slot ? *(slot) - 1 : LCC_NOT_FOUND);
1005 }
1006
1007 /* Return true if iterator LSE points to nothing.  */
1008 static inline bool
1009 lsei_end_p (lto_symtab_encoder_iterator lsei)
1010 {
1011   return lsei.index >= (unsigned)lto_symtab_encoder_size (lsei.encoder);
1012 }
1013
1014 /* Advance iterator LSE.  */
1015 static inline void
1016 lsei_next (lto_symtab_encoder_iterator *lsei)
1017 {
1018   lsei->index++;
1019 }
1020
1021 /* Return the node pointed to by LSI.  */
1022 static inline symtab_node *
1023 lsei_node (lto_symtab_encoder_iterator lsei)
1024 {
1025   return lsei.encoder->nodes[lsei.index].node;
1026 }
1027
1028 /* Return the node pointed to by LSI.  */
1029 static inline struct cgraph_node *
1030 lsei_cgraph_node (lto_symtab_encoder_iterator lsei)
1031 {
1032   return dyn_cast<cgraph_node *> (lsei.encoder->nodes[lsei.index].node);
1033 }
1034
1035 /* Return the node pointed to by LSI.  */
1036 static inline varpool_node *
1037 lsei_varpool_node (lto_symtab_encoder_iterator lsei)
1038 {
1039   return dyn_cast<varpool_node *> (lsei.encoder->nodes[lsei.index].node);
1040 }
1041
1042 /* Return the cgraph node corresponding to REF using ENCODER.  */
1043
1044 static inline symtab_node *
1045 lto_symtab_encoder_deref (lto_symtab_encoder_t encoder, int ref)
1046 {
1047   if (ref == LCC_NOT_FOUND)
1048     return NULL;
1049
1050   return encoder->nodes[ref].node;
1051 }
1052
1053 /* Return an iterator to the first node in LSI.  */
1054 static inline lto_symtab_encoder_iterator
1055 lsei_start (lto_symtab_encoder_t encoder)
1056 {
1057   lto_symtab_encoder_iterator lsei;
1058
1059   lsei.encoder = encoder;
1060   lsei.index = 0;
1061   return lsei;
1062 }
1063
1064 /* Advance iterator LSE.  */
1065 static inline void
1066 lsei_next_in_partition (lto_symtab_encoder_iterator *lsei)
1067 {
1068   lsei_next (lsei);
1069   while (!lsei_end_p (*lsei)
1070          && !lto_symtab_encoder_in_partition_p (lsei->encoder, lsei_node (*lsei)))
1071     lsei_next (lsei);
1072 }
1073
1074 /* Return an iterator to the first node in LSI.  */
1075 static inline lto_symtab_encoder_iterator
1076 lsei_start_in_partition (lto_symtab_encoder_t encoder)
1077 {
1078   lto_symtab_encoder_iterator lsei = lsei_start (encoder);
1079
1080   if (lsei_end_p (lsei))
1081     return lsei;
1082   if (!lto_symtab_encoder_in_partition_p (encoder, lsei_node (lsei)))
1083     lsei_next_in_partition (&lsei);
1084
1085   return lsei;
1086 }
1087
1088 /* Advance iterator LSE.  */
1089 static inline void
1090 lsei_next_function_in_partition (lto_symtab_encoder_iterator *lsei)
1091 {
1092   lsei_next (lsei);
1093   while (!lsei_end_p (*lsei)
1094          && (!is_a <cgraph_node *> (lsei_node (*lsei))
1095              || !lto_symtab_encoder_in_partition_p (lsei->encoder, lsei_node (*lsei))))
1096     lsei_next (lsei);
1097 }
1098
1099 /* Return an iterator to the first node in LSI.  */
1100 static inline lto_symtab_encoder_iterator
1101 lsei_start_function_in_partition (lto_symtab_encoder_t encoder)
1102 {
1103   lto_symtab_encoder_iterator lsei = lsei_start (encoder);
1104
1105   if (lsei_end_p (lsei))
1106     return lsei;
1107   if (!is_a <cgraph_node *> (lsei_node (lsei))
1108       || !lto_symtab_encoder_in_partition_p (encoder, lsei_node (lsei)))
1109     lsei_next_function_in_partition (&lsei);
1110
1111   return lsei;
1112 }
1113
1114 /* Advance iterator LSE.  */
1115 static inline void
1116 lsei_next_variable_in_partition (lto_symtab_encoder_iterator *lsei)
1117 {
1118   lsei_next (lsei);
1119   while (!lsei_end_p (*lsei)
1120          && (!is_a <varpool_node *> (lsei_node (*lsei))
1121              || !lto_symtab_encoder_in_partition_p (lsei->encoder, lsei_node (*lsei))))
1122     lsei_next (lsei);
1123 }
1124
1125 /* Return an iterator to the first node in LSI.  */
1126 static inline lto_symtab_encoder_iterator
1127 lsei_start_variable_in_partition (lto_symtab_encoder_t encoder)
1128 {
1129   lto_symtab_encoder_iterator lsei = lsei_start (encoder);
1130
1131   if (lsei_end_p (lsei))
1132     return lsei;
1133   if (!is_a <varpool_node *> (lsei_node (lsei))
1134       || !lto_symtab_encoder_in_partition_p (encoder, lsei_node (lsei)))
1135     lsei_next_variable_in_partition (&lsei);
1136
1137   return lsei;
1138 }
1139
1140 DEFINE_DECL_STREAM_FUNCS (TYPE, type)
1141 DEFINE_DECL_STREAM_FUNCS (FIELD_DECL, field_decl)
1142 DEFINE_DECL_STREAM_FUNCS (FN_DECL, fn_decl)
1143 DEFINE_DECL_STREAM_FUNCS (VAR_DECL, var_decl)
1144 DEFINE_DECL_STREAM_FUNCS (TYPE_DECL, type_decl)
1145 DEFINE_DECL_STREAM_FUNCS (NAMESPACE_DECL, namespace_decl)
1146 DEFINE_DECL_STREAM_FUNCS (LABEL_DECL, label_decl)
1147
1148 #endif /* GCC_LTO_STREAMER_H  */