OSDN Git Service

655cf89bc288b768fb91d5a389b018e7e90af545
[pf3gnuchains/gcc-fork.git] / gcc / lto-streamer-out.c
1 /* Write the GIMPLE representation to a file stream.
2
3    Copyright 2009, 2010 Free Software Foundation, Inc.
4    Contributed by Kenneth Zadeck <zadeck@naturalbridge.com>
5    Re-implemented by Diego Novillo <dnovillo@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 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "tm.h"
27 #include "tree.h"
28 #include "expr.h"
29 #include "flags.h"
30 #include "params.h"
31 #include "input.h"
32 #include "hashtab.h"
33 #include "basic-block.h"
34 #include "tree-flow.h"
35 #include "tree-pass.h"
36 #include "cgraph.h"
37 #include "function.h"
38 #include "ggc.h"
39 #include "diagnostic-core.h"
40 #include "except.h"
41 #include "vec.h"
42 #include "lto-symtab.h"
43 #include "lto-streamer.h"
44 #include "data-streamer.h"
45 #include "gimple-streamer.h"
46 #include "tree-streamer.h"
47 #include "streamer-hooks.h"
48
49
50 /* Clear the line info stored in DATA_IN.  */
51
52 static void
53 clear_line_info (struct output_block *ob)
54 {
55   ob->current_file = NULL;
56   ob->current_line = 0;
57   ob->current_col = 0;
58 }
59
60
61 /* Create the output block and return it.  SECTION_TYPE is
62    LTO_section_function_body or LTO_static_initializer.  */
63
64 struct output_block *
65 create_output_block (enum lto_section_type section_type)
66 {
67   struct output_block *ob = XCNEW (struct output_block);
68
69   ob->section_type = section_type;
70   ob->decl_state = lto_get_out_decl_state ();
71   ob->main_stream = XCNEW (struct lto_output_stream);
72   ob->string_stream = XCNEW (struct lto_output_stream);
73   ob->writer_cache = streamer_tree_cache_create ();
74
75   if (section_type == LTO_section_function_body)
76     ob->cfg_stream = XCNEW (struct lto_output_stream);
77
78   clear_line_info (ob);
79
80   ob->string_hash_table = htab_create (37, hash_string_slot_node,
81                                        eq_string_slot_node, NULL);
82   gcc_obstack_init (&ob->obstack);
83
84   return ob;
85 }
86
87
88 /* Destroy the output block OB.  */
89
90 void
91 destroy_output_block (struct output_block *ob)
92 {
93   enum lto_section_type section_type = ob->section_type;
94
95   htab_delete (ob->string_hash_table);
96
97   free (ob->main_stream);
98   free (ob->string_stream);
99   if (section_type == LTO_section_function_body)
100     free (ob->cfg_stream);
101
102   streamer_tree_cache_delete (ob->writer_cache);
103   obstack_free (&ob->obstack, NULL);
104
105   free (ob);
106 }
107
108
109 /* Look up NODE in the type table and write the index for it to OB.  */
110
111 static void
112 output_type_ref (struct output_block *ob, tree node)
113 {
114   streamer_write_record_start (ob, LTO_type_ref);
115   lto_output_type_ref_index (ob->decl_state, ob->main_stream, node);
116 }
117
118
119 /* Return true if tree node T is written to various tables.  For these
120    nodes, we sometimes want to write their phyiscal representation
121    (via lto_output_tree), and sometimes we need to emit an index
122    reference into a table (via lto_output_tree_ref).  */
123
124 static bool
125 tree_is_indexable (tree t)
126 {
127   if (TREE_CODE (t) == PARM_DECL)
128     return false;
129   else if (TREE_CODE (t) == VAR_DECL && decl_function_context (t)
130            && !TREE_STATIC (t))
131     return false;
132   /* If this is a decl generated for block local externs for
133      debug info generation, stream it unshared alongside BLOCK_VARS.  */
134   else if (VAR_OR_FUNCTION_DECL_P (t)
135            /* ???  The following tests are a literal match on what
136               c-decl.c:pop_scope does.  */
137            && TREE_PUBLIC (t)
138            && DECL_EXTERNAL (t)
139            && DECL_CONTEXT (t)
140            && TREE_CODE (DECL_CONTEXT (t)) == FUNCTION_DECL)
141     return false;
142   else
143     return (TYPE_P (t) || DECL_P (t) || TREE_CODE (t) == SSA_NAME);
144 }
145
146
147 /* Output info about new location into bitpack BP.
148    After outputting bitpack, lto_output_location_data has
149    to be done to output actual data.  */
150
151 static inline void
152 lto_output_location_bitpack (struct bitpack_d *bp,
153                              struct output_block *ob,
154                              location_t loc)
155 {
156   expanded_location xloc;
157
158   bp_pack_value (bp, loc == UNKNOWN_LOCATION, 1);
159   if (loc == UNKNOWN_LOCATION)
160     return;
161
162   xloc = expand_location (loc);
163
164   bp_pack_value (bp, ob->current_file != xloc.file, 1);
165   if (ob->current_file != xloc.file)
166     bp_pack_var_len_unsigned (bp,
167                               streamer_string_index (ob, xloc.file,
168                                                      strlen (xloc.file) + 1,
169                                                      true));
170   ob->current_file = xloc.file;
171
172   bp_pack_value (bp, ob->current_line != xloc.line, 1);
173   if (ob->current_line != xloc.line)
174     bp_pack_var_len_unsigned (bp, xloc.line);
175   ob->current_line = xloc.line;
176
177   bp_pack_value (bp, ob->current_col != xloc.column, 1);
178   if (ob->current_col != xloc.column)
179     bp_pack_var_len_unsigned (bp, xloc.column);
180   ob->current_col = xloc.column;
181 }
182
183
184 /* Emit location LOC to output block OB.
185    If the output_location streamer hook exists, call it.
186    Otherwise, when bitpack is handy, it is more space efficient to call
187    lto_output_location_bitpack with existing bitpack.  */
188
189 void
190 lto_output_location (struct output_block *ob, location_t loc)
191 {
192   if (streamer_hooks.output_location)
193     streamer_hooks.output_location (ob, loc);
194   else
195     {
196       struct bitpack_d bp = bitpack_create (ob->main_stream);
197       lto_output_location_bitpack (&bp, ob, loc);
198       streamer_write_bitpack (&bp);
199     }
200 }
201
202
203 /* If EXPR is an indexable tree node, output a reference to it to
204    output block OB.  Otherwise, output the physical representation of
205    EXPR to OB.  */
206
207 static void
208 lto_output_tree_ref (struct output_block *ob, tree expr)
209 {
210   enum tree_code code;
211
212   if (TYPE_P (expr))
213     {
214       output_type_ref (ob, expr);
215       return;
216     }
217
218   code = TREE_CODE (expr);
219   switch (code)
220     {
221     case SSA_NAME:
222       streamer_write_record_start (ob, LTO_ssa_name_ref);
223       streamer_write_uhwi (ob, SSA_NAME_VERSION (expr));
224       break;
225
226     case FIELD_DECL:
227       streamer_write_record_start (ob, LTO_field_decl_ref);
228       lto_output_field_decl_index (ob->decl_state, ob->main_stream, expr);
229       break;
230
231     case FUNCTION_DECL:
232       streamer_write_record_start (ob, LTO_function_decl_ref);
233       lto_output_fn_decl_index (ob->decl_state, ob->main_stream, expr);
234       break;
235
236     case VAR_DECL:
237     case DEBUG_EXPR_DECL:
238       gcc_assert (decl_function_context (expr) == NULL || TREE_STATIC (expr));
239       streamer_write_record_start (ob, LTO_global_decl_ref);
240       lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
241       break;
242
243     case CONST_DECL:
244       streamer_write_record_start (ob, LTO_const_decl_ref);
245       lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
246       break;
247
248     case IMPORTED_DECL:
249       gcc_assert (decl_function_context (expr) == NULL);
250       streamer_write_record_start (ob, LTO_imported_decl_ref);
251       lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
252       break;
253
254     case TYPE_DECL:
255       streamer_write_record_start (ob, LTO_type_decl_ref);
256       lto_output_type_decl_index (ob->decl_state, ob->main_stream, expr);
257       break;
258
259     case NAMESPACE_DECL:
260       streamer_write_record_start (ob, LTO_namespace_decl_ref);
261       lto_output_namespace_decl_index (ob->decl_state, ob->main_stream, expr);
262       break;
263
264     case LABEL_DECL:
265       streamer_write_record_start (ob, LTO_label_decl_ref);
266       lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
267       break;
268
269     case RESULT_DECL:
270       streamer_write_record_start (ob, LTO_result_decl_ref);
271       lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
272       break;
273
274     case TRANSLATION_UNIT_DECL:
275       streamer_write_record_start (ob, LTO_translation_unit_decl_ref);
276       lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
277       break;
278
279     default:
280       /* No other node is indexable, so it should have been handled by
281          lto_output_tree.  */
282       gcc_unreachable ();
283     }
284 }
285
286
287 /* Return true if EXPR is a tree node that can be written to disk.  */
288
289 static inline bool
290 lto_is_streamable (tree expr)
291 {
292   enum tree_code code = TREE_CODE (expr);
293
294   /* Notice that we reject SSA_NAMEs as well.  We only emit the SSA
295      name version in lto_output_tree_ref (see output_ssa_names).  */
296   return !is_lang_specific (expr)
297          && code != SSA_NAME
298          && code != CALL_EXPR
299          && code != LANG_TYPE
300          && code != MODIFY_EXPR
301          && code != INIT_EXPR
302          && code != TARGET_EXPR
303          && code != BIND_EXPR
304          && code != WITH_CLEANUP_EXPR
305          && code != STATEMENT_LIST
306          && code != OMP_CLAUSE
307          && code != OPTIMIZATION_NODE
308          && (code == CASE_LABEL_EXPR
309              || code == DECL_EXPR
310              || TREE_CODE_CLASS (code) != tcc_statement);
311 }
312
313
314 /* Write a physical representation of tree node EXPR to output block
315    OB.  If REF_P is true, the leaves of EXPR are emitted as references
316    via lto_output_tree_ref.  IX is the index into the streamer cache
317    where EXPR is stored.  */
318
319 static void
320 lto_write_tree (struct output_block *ob, tree expr, bool ref_p)
321 {
322   struct bitpack_d bp;
323
324   if (!lto_is_streamable (expr))
325     internal_error ("tree code %qs is not supported in LTO streams",
326                     tree_code_name[TREE_CODE (expr)]);
327
328   /* Write the header, containing everything needed to materialize
329      EXPR on the reading side.  */
330   streamer_write_tree_header (ob, expr);
331
332   /* Pack all the non-pointer fields in EXPR into a bitpack and write
333      the resulting bitpack.  */
334   bp = bitpack_create (ob->main_stream);
335   streamer_pack_tree_bitfields (&bp, expr);
336   streamer_write_bitpack (&bp);
337
338   /* Write all the pointer fields in EXPR.  */
339   streamer_write_tree_body (ob, expr, ref_p);
340
341   /* Write any LTO-specific data to OB.  */
342   if (DECL_P (expr)
343       && TREE_CODE (expr) != FUNCTION_DECL
344       && TREE_CODE (expr) != TRANSLATION_UNIT_DECL)
345     {
346       /* Handle DECL_INITIAL for symbols.  */
347       tree initial = DECL_INITIAL (expr);
348       if (TREE_CODE (expr) == VAR_DECL
349           && (TREE_STATIC (expr) || DECL_EXTERNAL (expr))
350           && initial)
351         {
352           lto_varpool_encoder_t varpool_encoder;
353           struct varpool_node *vnode;
354
355           varpool_encoder = ob->decl_state->varpool_node_encoder;
356           vnode = varpool_get_node (expr);
357           if (!vnode)
358             initial = error_mark_node;
359           else if (!lto_varpool_encoder_encode_initializer_p (varpool_encoder,
360                                                               vnode))
361             initial = NULL;
362         }
363
364       stream_write_tree (ob, initial, ref_p);
365     }
366
367   /* Mark the end of EXPR.  */
368   streamer_write_zero (ob);
369 }
370
371
372 /* Emit the physical representation of tree node EXPR to output block
373    OB.  If REF_P is true, the leaves of EXPR are emitted as references
374    via lto_output_tree_ref.  */
375
376 void
377 lto_output_tree (struct output_block *ob, tree expr, bool ref_p)
378 {
379   unsigned ix;
380   bool existed_p;
381
382   if (expr == NULL_TREE)
383     {
384       streamer_write_record_start (ob, LTO_null);
385       return;
386     }
387
388   if (ref_p && tree_is_indexable (expr))
389     {
390       lto_output_tree_ref (ob, expr);
391       return;
392     }
393
394   /* INTEGER_CST nodes are special because they need their original type
395      to be materialized by the reader (to implement TYPE_CACHED_VALUES).  */
396   if (TREE_CODE (expr) == INTEGER_CST)
397     {
398       streamer_write_integer_cst (ob, expr, ref_p);
399       return;
400     }
401
402   existed_p = streamer_tree_cache_insert (ob->writer_cache, expr, &ix);
403   if (existed_p)
404     {
405       /* If a node has already been streamed out, make sure that
406          we don't write it more than once.  Otherwise, the reader
407          will instantiate two different nodes for the same object.  */
408       streamer_write_record_start (ob, LTO_tree_pickle_reference);
409       streamer_write_uhwi (ob, ix);
410       streamer_write_enum (ob->main_stream, LTO_tags, LTO_NUM_TAGS,
411                            lto_tree_code_to_tag (TREE_CODE (expr)));
412     }
413   else if (streamer_handle_as_builtin_p (expr))
414     {
415       /* MD and NORMAL builtins do not need to be written out
416          completely as they are always instantiated by the
417          compiler on startup.  The only builtins that need to
418          be written out are BUILT_IN_FRONTEND.  For all other
419          builtins, we simply write the class and code.  */
420       streamer_write_builtin (ob, expr);
421     }
422   else
423     {
424       /* This is the first time we see EXPR, write its fields
425          to OB.  */
426       lto_write_tree (ob, expr, ref_p);
427     }
428 }
429
430
431 /* Output to OB a list of try/catch handlers starting with FIRST.  */
432
433 static void
434 output_eh_try_list (struct output_block *ob, eh_catch first)
435 {
436   eh_catch n;
437
438   for (n = first; n; n = n->next_catch)
439     {
440       streamer_write_record_start (ob, LTO_eh_catch);
441       stream_write_tree (ob, n->type_list, true);
442       stream_write_tree (ob, n->filter_list, true);
443       stream_write_tree (ob, n->label, true);
444     }
445
446   streamer_write_record_start (ob, LTO_null);
447 }
448
449
450 /* Output EH region R in function FN to OB.  CURR_RN is the slot index
451    that is being emitted in FN->EH->REGION_ARRAY.  This is used to
452    detect EH region sharing.  */
453
454 static void
455 output_eh_region (struct output_block *ob, eh_region r)
456 {
457   enum LTO_tags tag;
458
459   if (r == NULL)
460     {
461       streamer_write_record_start (ob, LTO_null);
462       return;
463     }
464
465   if (r->type == ERT_CLEANUP)
466     tag = LTO_ert_cleanup;
467   else if (r->type == ERT_TRY)
468     tag = LTO_ert_try;
469   else if (r->type == ERT_ALLOWED_EXCEPTIONS)
470     tag = LTO_ert_allowed_exceptions;
471   else if (r->type == ERT_MUST_NOT_THROW)
472     tag = LTO_ert_must_not_throw;
473   else
474     gcc_unreachable ();
475
476   streamer_write_record_start (ob, tag);
477   streamer_write_hwi (ob, r->index);
478
479   if (r->outer)
480     streamer_write_hwi (ob, r->outer->index);
481   else
482     streamer_write_zero (ob);
483
484   if (r->inner)
485     streamer_write_hwi (ob, r->inner->index);
486   else
487     streamer_write_zero (ob);
488
489   if (r->next_peer)
490     streamer_write_hwi (ob, r->next_peer->index);
491   else
492     streamer_write_zero (ob);
493
494   if (r->type == ERT_TRY)
495     {
496       output_eh_try_list (ob, r->u.eh_try.first_catch);
497     }
498   else if (r->type == ERT_ALLOWED_EXCEPTIONS)
499     {
500       stream_write_tree (ob, r->u.allowed.type_list, true);
501       stream_write_tree (ob, r->u.allowed.label, true);
502       streamer_write_uhwi (ob, r->u.allowed.filter);
503     }
504   else if (r->type == ERT_MUST_NOT_THROW)
505     {
506       stream_write_tree (ob, r->u.must_not_throw.failure_decl, true);
507       lto_output_location (ob, r->u.must_not_throw.failure_loc);
508     }
509
510   if (r->landing_pads)
511     streamer_write_hwi (ob, r->landing_pads->index);
512   else
513     streamer_write_zero (ob);
514 }
515
516
517 /* Output landing pad LP to OB.  */
518
519 static void
520 output_eh_lp (struct output_block *ob, eh_landing_pad lp)
521 {
522   if (lp == NULL)
523     {
524       streamer_write_record_start (ob, LTO_null);
525       return;
526     }
527
528   streamer_write_record_start (ob, LTO_eh_landing_pad);
529   streamer_write_hwi (ob, lp->index);
530   if (lp->next_lp)
531     streamer_write_hwi (ob, lp->next_lp->index);
532   else
533     streamer_write_zero (ob);
534
535   if (lp->region)
536     streamer_write_hwi (ob, lp->region->index);
537   else
538     streamer_write_zero (ob);
539
540   stream_write_tree (ob, lp->post_landing_pad, true);
541 }
542
543
544 /* Output the existing eh_table to OB.  */
545
546 static void
547 output_eh_regions (struct output_block *ob, struct function *fn)
548 {
549   if (fn->eh && fn->eh->region_tree)
550     {
551       unsigned i;
552       eh_region eh;
553       eh_landing_pad lp;
554       tree ttype;
555
556       streamer_write_record_start (ob, LTO_eh_table);
557
558       /* Emit the index of the root of the EH region tree.  */
559       streamer_write_hwi (ob, fn->eh->region_tree->index);
560
561       /* Emit all the EH regions in the region array.  */
562       streamer_write_hwi (ob, VEC_length (eh_region, fn->eh->region_array));
563       FOR_EACH_VEC_ELT (eh_region, fn->eh->region_array, i, eh)
564         output_eh_region (ob, eh);
565
566       /* Emit all landing pads.  */
567       streamer_write_hwi (ob, VEC_length (eh_landing_pad, fn->eh->lp_array));
568       FOR_EACH_VEC_ELT (eh_landing_pad, fn->eh->lp_array, i, lp)
569         output_eh_lp (ob, lp);
570
571       /* Emit all the runtime type data.  */
572       streamer_write_hwi (ob, VEC_length (tree, fn->eh->ttype_data));
573       FOR_EACH_VEC_ELT (tree, fn->eh->ttype_data, i, ttype)
574         stream_write_tree (ob, ttype, true);
575
576       /* Emit the table of action chains.  */
577       if (targetm.arm_eabi_unwinder)
578         {
579           tree t;
580           streamer_write_hwi (ob, VEC_length (tree,
581                                               fn->eh->ehspec_data.arm_eabi));
582           FOR_EACH_VEC_ELT (tree, fn->eh->ehspec_data.arm_eabi, i, t)
583             stream_write_tree (ob, t, true);
584         }
585       else
586         {
587           uchar c;
588           streamer_write_hwi (ob, VEC_length (uchar,
589                                               fn->eh->ehspec_data.other));
590           FOR_EACH_VEC_ELT (uchar, fn->eh->ehspec_data.other, i, c)
591             streamer_write_char_stream (ob->main_stream, c);
592         }
593     }
594
595   /* The LTO_null either terminates the record or indicates that there
596      are no eh_records at all.  */
597   streamer_write_record_start (ob, LTO_null);
598 }
599
600
601 /* Output all of the active ssa names to the ssa_names stream.  */
602
603 static void
604 output_ssa_names (struct output_block *ob, struct function *fn)
605 {
606   unsigned int i, len;
607
608   len = VEC_length (tree, SSANAMES (fn));
609   streamer_write_uhwi (ob, len);
610
611   for (i = 1; i < len; i++)
612     {
613       tree ptr = VEC_index (tree, SSANAMES (fn), i);
614
615       if (ptr == NULL_TREE
616           || SSA_NAME_IN_FREE_LIST (ptr)
617           || !is_gimple_reg (ptr))
618         continue;
619
620       streamer_write_uhwi (ob, i);
621       streamer_write_char_stream (ob->main_stream,
622                                   SSA_NAME_IS_DEFAULT_DEF (ptr));
623       stream_write_tree (ob, SSA_NAME_VAR (ptr), true);
624     }
625
626   streamer_write_zero (ob);
627 }
628
629
630 /* Output the cfg.  */
631
632 static void
633 output_cfg (struct output_block *ob, struct function *fn)
634 {
635   struct lto_output_stream *tmp_stream = ob->main_stream;
636   basic_block bb;
637
638   ob->main_stream = ob->cfg_stream;
639
640   streamer_write_enum (ob->main_stream, profile_status_d, PROFILE_LAST,
641                        profile_status_for_function (fn));
642
643   /* Output the number of the highest basic block.  */
644   streamer_write_uhwi (ob, last_basic_block_for_function (fn));
645
646   FOR_ALL_BB_FN (bb, fn)
647     {
648       edge_iterator ei;
649       edge e;
650
651       streamer_write_hwi (ob, bb->index);
652
653       /* Output the successors and the edge flags.  */
654       streamer_write_uhwi (ob, EDGE_COUNT (bb->succs));
655       FOR_EACH_EDGE (e, ei, bb->succs)
656         {
657           streamer_write_uhwi (ob, e->dest->index);
658           streamer_write_hwi (ob, e->probability);
659           streamer_write_hwi (ob, e->count);
660           streamer_write_uhwi (ob, e->flags);
661         }
662     }
663
664   streamer_write_hwi (ob, -1);
665
666   bb = ENTRY_BLOCK_PTR;
667   while (bb->next_bb)
668     {
669       streamer_write_hwi (ob, bb->next_bb->index);
670       bb = bb->next_bb;
671     }
672
673   streamer_write_hwi (ob, -1);
674
675   ob->main_stream = tmp_stream;
676 }
677
678
679 /* Create the header in the file using OB.  If the section type is for
680    a function, set FN to the decl for that function.  */
681
682 void
683 produce_asm (struct output_block *ob, tree fn)
684 {
685   enum lto_section_type section_type = ob->section_type;
686   struct lto_function_header header;
687   char *section_name;
688   struct lto_output_stream *header_stream;
689
690   if (section_type == LTO_section_function_body)
691     {
692       const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn));
693       section_name = lto_get_section_name (section_type, name, NULL);
694     }
695   else
696     section_name = lto_get_section_name (section_type, NULL, NULL);
697
698   lto_begin_section (section_name, !flag_wpa);
699   free (section_name);
700
701   /* The entire header is stream computed here.  */
702   memset (&header, 0, sizeof (struct lto_function_header));
703
704   /* Write the header.  */
705   header.lto_header.major_version = LTO_major_version;
706   header.lto_header.minor_version = LTO_minor_version;
707   header.lto_header.section_type = section_type;
708
709   header.compressed_size = 0;
710
711   if (section_type == LTO_section_function_body)
712     header.cfg_size = ob->cfg_stream->total_size;
713   header.main_size = ob->main_stream->total_size;
714   header.string_size = ob->string_stream->total_size;
715
716   header_stream = XCNEW (struct lto_output_stream);
717   lto_output_data_stream (header_stream, &header, sizeof header);
718   lto_write_stream (header_stream);
719   free (header_stream);
720
721   /* Put all of the gimple and the string table out the asm file as a
722      block of text.  */
723   if (section_type == LTO_section_function_body)
724     lto_write_stream (ob->cfg_stream);
725   lto_write_stream (ob->main_stream);
726   lto_write_stream (ob->string_stream);
727
728   lto_end_section ();
729 }
730
731
732 /* Output the base body of struct function FN using output block OB.  */
733
734 static void
735 output_struct_function_base (struct output_block *ob, struct function *fn)
736 {
737   struct bitpack_d bp;
738   unsigned i;
739   tree t;
740
741   /* Output the static chain and non-local goto save area.  */
742   stream_write_tree (ob, fn->static_chain_decl, true);
743   stream_write_tree (ob, fn->nonlocal_goto_save_area, true);
744
745   /* Output all the local variables in the function.  */
746   streamer_write_hwi (ob, VEC_length (tree, fn->local_decls));
747   FOR_EACH_VEC_ELT (tree, fn->local_decls, i, t)
748     stream_write_tree (ob, t, true);
749
750   /* Output the function start and end loci.  */
751   lto_output_location (ob, fn->function_start_locus);
752   lto_output_location (ob, fn->function_end_locus);
753
754   /* Output current IL state of the function.  */
755   streamer_write_uhwi (ob, fn->curr_properties);
756
757   /* Write all the attributes for FN.  */
758   bp = bitpack_create (ob->main_stream);
759   bp_pack_value (&bp, fn->is_thunk, 1);
760   bp_pack_value (&bp, fn->has_local_explicit_reg_vars, 1);
761   bp_pack_value (&bp, fn->after_tree_profile, 1);
762   bp_pack_value (&bp, fn->returns_pcc_struct, 1);
763   bp_pack_value (&bp, fn->returns_struct, 1);
764   bp_pack_value (&bp, fn->can_throw_non_call_exceptions, 1);
765   bp_pack_value (&bp, fn->always_inline_functions_inlined, 1);
766   bp_pack_value (&bp, fn->after_inlining, 1);
767   bp_pack_value (&bp, fn->stdarg, 1);
768   bp_pack_value (&bp, fn->has_nonlocal_label, 1);
769   bp_pack_value (&bp, fn->calls_alloca, 1);
770   bp_pack_value (&bp, fn->calls_setjmp, 1);
771   bp_pack_value (&bp, fn->va_list_fpr_size, 8);
772   bp_pack_value (&bp, fn->va_list_gpr_size, 8);
773   streamer_write_bitpack (&bp);
774 }
775
776
777 /* Output the body of function NODE->DECL.  */
778
779 static void
780 output_function (struct cgraph_node *node)
781 {
782   tree function;
783   struct function *fn;
784   basic_block bb;
785   struct output_block *ob;
786
787   function = node->decl;
788   fn = DECL_STRUCT_FUNCTION (function);
789   ob = create_output_block (LTO_section_function_body);
790
791   clear_line_info (ob);
792   ob->cgraph_node = node;
793
794   gcc_assert (current_function_decl == NULL_TREE && cfun == NULL);
795
796   /* Set current_function_decl and cfun.  */
797   current_function_decl = function;
798   push_cfun (fn);
799
800   /* Make string 0 be a NULL string.  */
801   streamer_write_char_stream (ob->string_stream, 0);
802
803   streamer_write_record_start (ob, LTO_function);
804
805   output_struct_function_base (ob, fn);
806
807   /* Output the head of the arguments list.  */
808   stream_write_tree (ob, DECL_ARGUMENTS (function), true);
809
810   /* Output all the SSA names used in the function.  */
811   output_ssa_names (ob, fn);
812
813   /* Output any exception handling regions.  */
814   output_eh_regions (ob, fn);
815
816   /* Output DECL_INITIAL for the function, which contains the tree of
817      lexical scopes.  */
818   stream_write_tree (ob, DECL_INITIAL (function), true);
819
820   /* We will renumber the statements.  The code that does this uses
821      the same ordering that we use for serializing them so we can use
822      the same code on the other end and not have to write out the
823      statement numbers.  We do not assign UIDs to PHIs here because
824      virtual PHIs get re-computed on-the-fly which would make numbers
825      inconsistent.  */
826   set_gimple_stmt_max_uid (cfun, 0);
827   FOR_ALL_BB (bb)
828     {
829       gimple_stmt_iterator gsi;
830       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
831         {
832           gimple stmt = gsi_stmt (gsi);
833           gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun));
834         }
835     }
836
837   /* Output the code for the function.  */
838   FOR_ALL_BB_FN (bb, fn)
839     output_bb (ob, bb, fn);
840
841   /* The terminator for this function.  */
842   streamer_write_record_start (ob, LTO_null);
843
844   output_cfg (ob, fn);
845
846   /* Create a section to hold the pickled output of this function.   */
847   produce_asm (ob, function);
848
849   destroy_output_block (ob);
850
851   current_function_decl = NULL;
852   pop_cfun ();
853 }
854
855
856 /* Used to pass data to trivally_defined_alias callback.  */
857 struct sets {
858   cgraph_node_set set;
859   varpool_node_set vset;
860 };
861
862
863 /* Return true if alias pair P belongs to the set of cgraph nodes in
864    SET.  If P is a an alias for a VAR_DECL, it can always be emitted.
865    However, for FUNCTION_DECL aliases, we should only output the pair
866    if it belongs to a function whose cgraph node is in SET.
867    Otherwise, the LTRANS phase will get into trouble when finalizing
868    aliases because the alias will refer to a function not defined in
869    the file processed by LTRANS.  */
870
871 static bool
872 trivally_defined_alias (tree decl ATTRIBUTE_UNUSED,
873                         tree target, void *data)
874 {
875   struct sets *set = (struct sets *) data;
876   struct cgraph_node *fnode = NULL;
877   struct varpool_node *vnode = NULL;
878
879   fnode = cgraph_node_for_asm (target);
880   if (fnode)
881     return cgraph_node_in_set_p (fnode, set->set);
882   vnode = varpool_node_for_asm (target);
883   return vnode && varpool_node_in_set_p (vnode, set->vset);
884 }
885
886 /* Return true if alias pair P should be output in the current
887    partition contains cgrpah nodes SET and varpool nodes VSET.
888    DEFINED is set of all aliases whose targets are defined in
889    the partition.
890
891    Normal aliases are output when they are defined, while WEAKREF
892    aliases are output when they are used.  */
893
894 static bool
895 output_alias_pair_p (alias_pair *p, symbol_alias_set_t *defined,
896                      cgraph_node_set set, varpool_node_set vset)
897 {
898   struct cgraph_node *node;
899   struct varpool_node *vnode;
900
901   if (lookup_attribute ("weakref", DECL_ATTRIBUTES (p->decl)))
902     {
903       if (TREE_CODE (p->decl) == VAR_DECL)
904         {
905           vnode = varpool_get_node (p->decl);
906           return (vnode
907                   && referenced_from_this_partition_p (&vnode->ref_list, set, vset));
908         }
909       node = cgraph_get_node (p->decl);
910       return (node
911               && (referenced_from_this_partition_p (&node->ref_list, set, vset)
912                   || reachable_from_this_partition_p (node, set)));
913     }
914   else
915     return symbol_alias_set_contains (defined, p->decl);
916 }
917
918 /* Output any unreferenced global symbol defined in SET, alias pairs
919    and labels.  */
920
921 static void
922 output_unreferenced_globals (cgraph_node_set set, varpool_node_set vset)
923 {
924   struct output_block *ob;
925   alias_pair *p;
926   unsigned i;
927   symbol_alias_set_t *defined;
928   struct sets setdata;
929
930   setdata.set = set;
931   setdata.vset = vset;
932
933   ob = create_output_block (LTO_section_static_initializer);
934   ob->cgraph_node = NULL;
935
936   clear_line_info (ob);
937
938   /* Make string 0 be a NULL string.  */
939   streamer_write_char_stream (ob->string_stream, 0);
940
941   /* We really need to propagate in both directoins:
942      for normal aliases we propagate from first defined alias to
943      all aliases defined based on it.  For weakrefs we propagate in
944      the oposite direction.  */
945   defined = propagate_aliases_backward (trivally_defined_alias, &setdata);
946
947   /* Emit the alias pairs for the nodes in SET.  */
948   FOR_EACH_VEC_ELT (alias_pair, alias_pairs, i, p)
949     if (output_alias_pair_p (p, defined, set, vset))
950       {
951         stream_write_tree (ob, p->decl, true);
952         stream_write_tree (ob, p->target, true);
953       }
954   symbol_alias_set_destroy (defined);
955
956   streamer_write_record_start (ob, LTO_null);
957
958   produce_asm (ob, NULL);
959   destroy_output_block (ob);
960 }
961
962
963 /* Emit toplevel asms.  */
964
965 void
966 lto_output_toplevel_asms (void)
967 {
968   struct output_block *ob;
969   struct cgraph_asm_node *can;
970   char *section_name;
971   struct lto_output_stream *header_stream;
972   struct lto_asm_header header;
973
974   if (! cgraph_asm_nodes)
975     return;
976
977   ob = create_output_block (LTO_section_asm);
978
979   /* Make string 0 be a NULL string.  */
980   streamer_write_char_stream (ob->string_stream, 0);
981
982   for (can = cgraph_asm_nodes; can; can = can->next)
983     {
984       streamer_write_string_cst (ob, ob->main_stream, can->asm_str);
985       streamer_write_hwi (ob, can->order);
986     }
987
988   streamer_write_string_cst (ob, ob->main_stream, NULL_TREE);
989
990   section_name = lto_get_section_name (LTO_section_asm, NULL, NULL);
991   lto_begin_section (section_name, !flag_wpa);
992   free (section_name);
993
994   /* The entire header stream is computed here.  */
995   memset (&header, 0, sizeof (header));
996
997   /* Write the header.  */
998   header.lto_header.major_version = LTO_major_version;
999   header.lto_header.minor_version = LTO_minor_version;
1000   header.lto_header.section_type = LTO_section_asm;
1001
1002   header.main_size = ob->main_stream->total_size;
1003   header.string_size = ob->string_stream->total_size;
1004
1005   header_stream = XCNEW (struct lto_output_stream);
1006   lto_output_data_stream (header_stream, &header, sizeof (header));
1007   lto_write_stream (header_stream);
1008   free (header_stream);
1009
1010   /* Put all of the gimple and the string table out the asm file as a
1011      block of text.  */
1012   lto_write_stream (ob->main_stream);
1013   lto_write_stream (ob->string_stream);
1014
1015   lto_end_section ();
1016
1017   destroy_output_block (ob);
1018 }
1019
1020
1021 /* Copy the function body of NODE without deserializing. */
1022
1023 static void
1024 copy_function (struct cgraph_node *node)
1025 {
1026   tree function = node->decl;
1027   struct lto_file_decl_data *file_data = node->local.lto_file_data;
1028   struct lto_output_stream *output_stream = XCNEW (struct lto_output_stream);
1029   const char *data;
1030   size_t len;
1031   const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function));
1032   char *section_name =
1033     lto_get_section_name (LTO_section_function_body, name, NULL);
1034   size_t i, j;
1035   struct lto_in_decl_state *in_state;
1036   struct lto_out_decl_state *out_state = lto_get_out_decl_state ();
1037
1038   lto_begin_section (section_name, !flag_wpa);
1039   free (section_name);
1040
1041   /* We may have renamed the declaration, e.g., a static function.  */
1042   name = lto_get_decl_name_mapping (file_data, name);
1043
1044   data = lto_get_section_data (file_data, LTO_section_function_body,
1045                                name, &len);
1046   gcc_assert (data);
1047
1048   /* Do a bit copy of the function body.  */
1049   lto_output_data_stream (output_stream, data, len);
1050   lto_write_stream (output_stream);
1051
1052   /* Copy decls. */
1053   in_state =
1054     lto_get_function_in_decl_state (node->local.lto_file_data, function);
1055   gcc_assert (in_state);
1056
1057   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
1058     {
1059       size_t n = in_state->streams[i].size;
1060       tree *trees = in_state->streams[i].trees;
1061       struct lto_tree_ref_encoder *encoder = &(out_state->streams[i]);
1062
1063       /* The out state must have the same indices and the in state.
1064          So just copy the vector.  All the encoders in the in state
1065          must be empty where we reach here. */
1066       gcc_assert (lto_tree_ref_encoder_size (encoder) == 0);
1067       for (j = 0; j < n; j++)
1068         VEC_safe_push (tree, heap, encoder->trees, trees[j]);
1069       encoder->next_index = n;
1070     }
1071
1072   lto_free_section_data (file_data, LTO_section_function_body, name,
1073                          data, len);
1074   free (output_stream);
1075   lto_end_section ();
1076 }
1077
1078
1079 /* Main entry point from the pass manager.  */
1080
1081 static void
1082 lto_output (cgraph_node_set set, varpool_node_set vset)
1083 {
1084   struct cgraph_node *node;
1085   struct lto_out_decl_state *decl_state;
1086 #ifdef ENABLE_CHECKING
1087   bitmap output = lto_bitmap_alloc ();
1088 #endif
1089   int i, n_nodes;
1090   lto_cgraph_encoder_t encoder = lto_get_out_decl_state ()->cgraph_node_encoder;
1091
1092   /* Initialize the streamer.  */
1093   lto_streamer_init ();
1094
1095   n_nodes = lto_cgraph_encoder_size (encoder);
1096   /* Process only the functions with bodies.  */
1097   for (i = 0; i < n_nodes; i++)
1098     {
1099       node = lto_cgraph_encoder_deref (encoder, i);
1100       if (lto_cgraph_encoder_encode_body_p (encoder, node)
1101           && !node->alias
1102           && !node->thunk.thunk_p)
1103         {
1104 #ifdef ENABLE_CHECKING
1105           gcc_assert (!bitmap_bit_p (output, DECL_UID (node->decl)));
1106           bitmap_set_bit (output, DECL_UID (node->decl));
1107 #endif
1108           decl_state = lto_new_out_decl_state ();
1109           lto_push_out_decl_state (decl_state);
1110           if (gimple_has_body_p (node->decl))
1111             output_function (node);
1112           else
1113             copy_function (node);
1114           gcc_assert (lto_get_out_decl_state () == decl_state);
1115           lto_pop_out_decl_state ();
1116           lto_record_function_out_decl_state (node->decl, decl_state);
1117         }
1118     }
1119
1120   /* Emit the callgraph after emitting function bodies.  This needs to
1121      be done now to make sure that all the statements in every function
1122      have been renumbered so that edges can be associated with call
1123      statements using the statement UIDs.  */
1124   output_cgraph (set, vset);
1125
1126 #ifdef ENABLE_CHECKING
1127   lto_bitmap_free (output);
1128 #endif
1129 }
1130
1131 struct ipa_opt_pass_d pass_ipa_lto_gimple_out =
1132 {
1133  {
1134   IPA_PASS,
1135   "lto_gimple_out",                     /* name */
1136   gate_lto_out,                         /* gate */
1137   NULL,                                 /* execute */
1138   NULL,                                 /* sub */
1139   NULL,                                 /* next */
1140   0,                                    /* static_pass_number */
1141   TV_IPA_LTO_GIMPLE_OUT,                        /* tv_id */
1142   0,                                    /* properties_required */
1143   0,                                    /* properties_provided */
1144   0,                                    /* properties_destroyed */
1145   0,                                    /* todo_flags_start */
1146   0                                     /* todo_flags_finish */
1147  },
1148  NULL,                                  /* generate_summary */
1149  lto_output,                            /* write_summary */
1150  NULL,                                  /* read_summary */
1151  lto_output,                            /* write_optimization_summary */
1152  NULL,                                  /* read_optimization_summary */
1153  NULL,                                  /* stmt_fixup */
1154  0,                                     /* TODOs */
1155  NULL,                                  /* function_transform */
1156  NULL                                   /* variable_transform */
1157 };
1158
1159
1160 /* Write each node in encoded by ENCODER to OB, as well as those reachable
1161    from it and required for correct representation of its semantics.
1162    Each node in ENCODER must be a global declaration or a type.  A node
1163    is written only once, even if it appears multiple times in the
1164    vector.  Certain transitively-reachable nodes, such as those
1165    representing expressions, may be duplicated, but such nodes
1166    must not appear in ENCODER itself.  */
1167
1168 static void
1169 write_global_stream (struct output_block *ob,
1170                      struct lto_tree_ref_encoder *encoder)
1171 {
1172   tree t;
1173   size_t index;
1174   const size_t size = lto_tree_ref_encoder_size (encoder);
1175
1176   for (index = 0; index < size; index++)
1177     {
1178       t = lto_tree_ref_encoder_get_tree (encoder, index);
1179       if (!streamer_tree_cache_lookup (ob->writer_cache, t, NULL))
1180         stream_write_tree (ob, t, false);
1181     }
1182 }
1183
1184
1185 /* Write a sequence of indices into the globals vector corresponding
1186    to the trees in ENCODER.  These are used by the reader to map the
1187    indices used to refer to global entities within function bodies to
1188    their referents.  */
1189
1190 static void
1191 write_global_references (struct output_block *ob,
1192                          struct lto_output_stream *ref_stream,
1193                          struct lto_tree_ref_encoder *encoder)
1194 {
1195   tree t;
1196   uint32_t index;
1197   const uint32_t size = lto_tree_ref_encoder_size (encoder);
1198
1199   /* Write size as 32-bit unsigned. */
1200   lto_output_data_stream (ref_stream, &size, sizeof (int32_t));
1201
1202   for (index = 0; index < size; index++)
1203     {
1204       uint32_t slot_num;
1205
1206       t = lto_tree_ref_encoder_get_tree (encoder, index);
1207       streamer_tree_cache_lookup (ob->writer_cache, t, &slot_num);
1208       gcc_assert (slot_num != (unsigned)-1);
1209       lto_output_data_stream (ref_stream, &slot_num, sizeof slot_num);
1210     }
1211 }
1212
1213
1214 /* Write all the streams in an lto_out_decl_state STATE using
1215    output block OB and output stream OUT_STREAM.  */
1216
1217 void
1218 lto_output_decl_state_streams (struct output_block *ob,
1219                                struct lto_out_decl_state *state)
1220 {
1221   int i;
1222
1223   for (i = 0;  i < LTO_N_DECL_STREAMS; i++)
1224     write_global_stream (ob, &state->streams[i]);
1225 }
1226
1227
1228 /* Write all the references in an lto_out_decl_state STATE using
1229    output block OB and output stream OUT_STREAM.  */
1230
1231 void
1232 lto_output_decl_state_refs (struct output_block *ob,
1233                             struct lto_output_stream *out_stream,
1234                             struct lto_out_decl_state *state)
1235 {
1236   unsigned i;
1237   uint32_t ref;
1238   tree decl;
1239
1240   /* Write reference to FUNCTION_DECL.  If there is not function,
1241      write reference to void_type_node. */
1242   decl = (state->fn_decl) ? state->fn_decl : void_type_node;
1243   streamer_tree_cache_lookup (ob->writer_cache, decl, &ref);
1244   gcc_assert (ref != (unsigned)-1);
1245   lto_output_data_stream (out_stream, &ref, sizeof (uint32_t));
1246
1247   for (i = 0;  i < LTO_N_DECL_STREAMS; i++)
1248     write_global_references (ob, out_stream, &state->streams[i]);
1249 }
1250
1251
1252 /* Return the written size of STATE. */
1253
1254 static size_t
1255 lto_out_decl_state_written_size (struct lto_out_decl_state *state)
1256 {
1257   int i;
1258   size_t size;
1259
1260   size = sizeof (int32_t);      /* fn_ref. */
1261   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
1262     {
1263       size += sizeof (int32_t); /* vector size. */
1264       size += (lto_tree_ref_encoder_size (&state->streams[i])
1265                * sizeof (int32_t));
1266     }
1267   return size;
1268 }
1269
1270
1271 /* Write symbol T into STREAM in CACHE. SEEN specifies symbols we wrote
1272    so far.  */
1273
1274 static void
1275 write_symbol (struct streamer_tree_cache_d *cache,
1276               struct lto_output_stream *stream,
1277               tree t, struct pointer_set_t *seen, bool alias)
1278 {
1279   const char *name;
1280   enum gcc_plugin_symbol_kind kind;
1281   enum gcc_plugin_symbol_visibility visibility;
1282   unsigned slot_num;
1283   uint64_t size;
1284   const char *comdat;
1285   unsigned char c;
1286
1287   /* None of the following kinds of symbols are needed in the
1288      symbol table.  */
1289   if (!TREE_PUBLIC (t)
1290       || is_builtin_fn (t)
1291       || DECL_ABSTRACT (t)
1292       || TREE_CODE (t) == RESULT_DECL)
1293     return;
1294
1295   gcc_assert (TREE_CODE (t) == VAR_DECL
1296               || TREE_CODE (t) == FUNCTION_DECL);
1297
1298   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t));
1299
1300   /* This behaves like assemble_name_raw in varasm.c, performing the
1301      same name manipulations that ASM_OUTPUT_LABELREF does. */
1302   name = IDENTIFIER_POINTER ((*targetm.asm_out.mangle_assembler_name) (name));
1303
1304   if (pointer_set_contains (seen, name))
1305     return;
1306   pointer_set_insert (seen, name);
1307
1308   streamer_tree_cache_lookup (cache, t, &slot_num);
1309   gcc_assert (slot_num != (unsigned)-1);
1310
1311   if (DECL_EXTERNAL (t))
1312     {
1313       if (DECL_WEAK (t))
1314         kind = GCCPK_WEAKUNDEF;
1315       else
1316         kind = GCCPK_UNDEF;
1317     }
1318   else
1319     {
1320       if (DECL_WEAK (t))
1321         kind = GCCPK_WEAKDEF;
1322       else if (DECL_COMMON (t))
1323         kind = GCCPK_COMMON;
1324       else
1325         kind = GCCPK_DEF;
1326
1327       /* When something is defined, it should have node attached.  */
1328       gcc_assert (alias || TREE_CODE (t) != VAR_DECL
1329                   || varpool_get_node (t)->finalized);
1330       gcc_assert (alias || TREE_CODE (t) != FUNCTION_DECL
1331                   || (cgraph_get_node (t)
1332                       && cgraph_get_node (t)->analyzed));
1333     }
1334
1335   /* Imitate what default_elf_asm_output_external do.
1336      When symbol is external, we need to output it with DEFAULT visibility
1337      when compiling with -fvisibility=default, while with HIDDEN visibility
1338      when symbol has attribute (visibility("hidden")) specified.
1339      targetm.binds_local_p check DECL_VISIBILITY_SPECIFIED and gets this
1340      right. */
1341      
1342   if (DECL_EXTERNAL (t)
1343       && !targetm.binds_local_p (t))
1344     visibility = GCCPV_DEFAULT;
1345   else
1346     switch (DECL_VISIBILITY(t))
1347       {
1348       case VISIBILITY_DEFAULT:
1349         visibility = GCCPV_DEFAULT;
1350         break;
1351       case VISIBILITY_PROTECTED:
1352         visibility = GCCPV_PROTECTED;
1353         break;
1354       case VISIBILITY_HIDDEN:
1355         visibility = GCCPV_HIDDEN;
1356         break;
1357       case VISIBILITY_INTERNAL:
1358         visibility = GCCPV_INTERNAL;
1359         break;
1360       }
1361
1362   if (kind == GCCPK_COMMON
1363       && DECL_SIZE (t)
1364       && TREE_CODE (DECL_SIZE (t)) == INTEGER_CST)
1365     {
1366       size = (HOST_BITS_PER_WIDE_INT >= 64)
1367         ? (uint64_t) int_size_in_bytes (TREE_TYPE (t))
1368         : (((uint64_t) TREE_INT_CST_HIGH (DECL_SIZE_UNIT (t))) << 32)
1369                 | TREE_INT_CST_LOW (DECL_SIZE_UNIT (t));
1370     }
1371   else
1372     size = 0;
1373
1374   if (DECL_ONE_ONLY (t))
1375     comdat = IDENTIFIER_POINTER (DECL_COMDAT_GROUP (t));
1376   else
1377     comdat = "";
1378
1379   lto_output_data_stream (stream, name, strlen (name) + 1);
1380   lto_output_data_stream (stream, comdat, strlen (comdat) + 1);
1381   c = (unsigned char) kind;
1382   lto_output_data_stream (stream, &c, 1);
1383   c = (unsigned char) visibility;
1384   lto_output_data_stream (stream, &c, 1);
1385   lto_output_data_stream (stream, &size, 8);
1386   lto_output_data_stream (stream, &slot_num, 4);
1387 }
1388
1389
1390 /* Write an IL symbol table to OB.
1391    SET and VSET are cgraph/varpool node sets we are outputting.  */
1392
1393 static void
1394 produce_symtab (struct output_block *ob,
1395                 cgraph_node_set set, varpool_node_set vset)
1396 {
1397   struct streamer_tree_cache_d *cache = ob->writer_cache;
1398   char *section_name = lto_get_section_name (LTO_section_symtab, NULL, NULL);
1399   struct pointer_set_t *seen;
1400   struct cgraph_node *node;
1401   struct varpool_node *vnode;
1402   struct lto_output_stream stream;
1403   lto_varpool_encoder_t varpool_encoder = ob->decl_state->varpool_node_encoder;
1404   lto_cgraph_encoder_t encoder = ob->decl_state->cgraph_node_encoder;
1405   int i;
1406   alias_pair *p;
1407   struct sets setdata;
1408   symbol_alias_set_t *defined;
1409
1410   setdata.set = set;
1411   setdata.vset = vset;
1412
1413   lto_begin_section (section_name, false);
1414   free (section_name);
1415
1416   seen = pointer_set_create ();
1417   memset (&stream, 0, sizeof (stream));
1418
1419   /* Write all functions. 
1420      First write all defined functions and then write all used functions.
1421      This is done so only to handle duplicated symbols in cgraph.  */
1422   for (i = 0; i < lto_cgraph_encoder_size (encoder); i++)
1423     {
1424       node = lto_cgraph_encoder_deref (encoder, i);
1425       if (DECL_EXTERNAL (node->decl))
1426         continue;
1427       if (DECL_COMDAT (node->decl)
1428           && cgraph_comdat_can_be_unshared_p (node))
1429         continue;
1430       if ((node->alias && !node->thunk.alias) || node->global.inlined_to)
1431         continue;
1432       write_symbol (cache, &stream, node->decl, seen, false);
1433     }
1434   for (i = 0; i < lto_cgraph_encoder_size (encoder); i++)
1435     {
1436       node = lto_cgraph_encoder_deref (encoder, i);
1437       if (!DECL_EXTERNAL (node->decl))
1438         continue;
1439       /* We keep around unused extern inlines in order to be able to inline
1440          them indirectly or via vtables.  Do not output them to symbol
1441          table: they end up being undefined and just consume space.  */
1442       if (!node->address_taken && !node->callers)
1443         {
1444           gcc_assert (node->analyzed);
1445           gcc_assert (DECL_DECLARED_INLINE_P (node->decl));
1446           continue;
1447         }
1448       if (DECL_COMDAT (node->decl)
1449           && cgraph_comdat_can_be_unshared_p (node))
1450         continue;
1451       if ((node->alias && !node->thunk.alias) || node->global.inlined_to)
1452         continue;
1453       write_symbol (cache, &stream, node->decl, seen, false);
1454     }
1455
1456   /* Write all variables.  */
1457   for (i = 0; i < lto_varpool_encoder_size (varpool_encoder); i++)
1458     {
1459       vnode = lto_varpool_encoder_deref (varpool_encoder, i);
1460       if (DECL_EXTERNAL (vnode->decl))
1461         continue;
1462       /* COMDAT virtual tables can be unshared.  Do not declare them
1463          in the LTO symbol table to prevent linker from forcing them
1464          into the output. */
1465       if (DECL_COMDAT (vnode->decl)
1466           && !vnode->force_output
1467           && vnode->finalized 
1468           && DECL_VIRTUAL_P (vnode->decl))
1469         continue;
1470       if (vnode->alias && !vnode->alias_of)
1471         continue;
1472       write_symbol (cache, &stream, vnode->decl, seen, false);
1473     }
1474   for (i = 0; i < lto_varpool_encoder_size (varpool_encoder); i++)
1475     {
1476       vnode = lto_varpool_encoder_deref (varpool_encoder, i);
1477       if (!DECL_EXTERNAL (vnode->decl))
1478         continue;
1479       if (DECL_COMDAT (vnode->decl)
1480           && !vnode->force_output
1481           && vnode->finalized 
1482           && DECL_VIRTUAL_P (vnode->decl))
1483         continue;
1484       if (vnode->alias && !vnode->alias_of)
1485         continue;
1486       write_symbol (cache, &stream, vnode->decl, seen, false);
1487     }
1488
1489   /* Write all aliases.  */
1490   defined = propagate_aliases_backward (trivally_defined_alias, &setdata);
1491   FOR_EACH_VEC_ELT (alias_pair, alias_pairs, i, p)
1492     if (output_alias_pair_p (p, defined, set, vset))
1493       write_symbol (cache, &stream, p->decl, seen, true);
1494   symbol_alias_set_destroy (defined);
1495
1496   lto_write_stream (&stream);
1497   pointer_set_destroy (seen);
1498
1499   lto_end_section ();
1500 }
1501
1502
1503 /* This pass is run after all of the functions are serialized and all
1504    of the IPA passes have written their serialized forms.  This pass
1505    causes the vector of all of the global decls and types used from
1506    this file to be written in to a section that can then be read in to
1507    recover these on other side.  */
1508
1509 static void
1510 produce_asm_for_decls (cgraph_node_set set, varpool_node_set vset)
1511 {
1512   struct lto_out_decl_state *out_state;
1513   struct lto_out_decl_state *fn_out_state;
1514   struct lto_decl_header header;
1515   char *section_name;
1516   struct output_block *ob;
1517   struct lto_output_stream *header_stream, *decl_state_stream;
1518   unsigned idx, num_fns;
1519   size_t decl_state_size;
1520   int32_t num_decl_states;
1521
1522   ob = create_output_block (LTO_section_decls);
1523   ob->global = true;
1524
1525   /* Write out unreferenced globals, alias pairs and labels.  We defer
1526      doing this until now so that we can write out only what is
1527      needed.  */
1528   output_unreferenced_globals (set, vset);
1529
1530   memset (&header, 0, sizeof (struct lto_decl_header));
1531
1532   section_name = lto_get_section_name (LTO_section_decls, NULL, NULL);
1533   lto_begin_section (section_name, !flag_wpa);
1534   free (section_name);
1535
1536   /* Make string 0 be a NULL string.  */
1537   streamer_write_char_stream (ob->string_stream, 0);
1538
1539   /* Write the global symbols.  */
1540   out_state = lto_get_out_decl_state ();
1541   num_fns = VEC_length (lto_out_decl_state_ptr, lto_function_decl_states);
1542   lto_output_decl_state_streams (ob, out_state);
1543   for (idx = 0; idx < num_fns; idx++)
1544     {
1545       fn_out_state =
1546         VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
1547       lto_output_decl_state_streams (ob, fn_out_state);
1548     }
1549
1550   header.lto_header.major_version = LTO_major_version;
1551   header.lto_header.minor_version = LTO_minor_version;
1552   header.lto_header.section_type = LTO_section_decls;
1553
1554   /* Currently not used.  This field would allow us to preallocate
1555      the globals vector, so that it need not be resized as it is extended.  */
1556   header.num_nodes = -1;
1557
1558   /* Compute the total size of all decl out states. */
1559   decl_state_size = sizeof (int32_t);
1560   decl_state_size += lto_out_decl_state_written_size (out_state);
1561   for (idx = 0; idx < num_fns; idx++)
1562     {
1563       fn_out_state =
1564         VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
1565       decl_state_size += lto_out_decl_state_written_size (fn_out_state);
1566     }
1567   header.decl_state_size = decl_state_size;
1568
1569   header.main_size = ob->main_stream->total_size;
1570   header.string_size = ob->string_stream->total_size;
1571
1572   header_stream = XCNEW (struct lto_output_stream);
1573   lto_output_data_stream (header_stream, &header, sizeof header);
1574   lto_write_stream (header_stream);
1575   free (header_stream);
1576
1577   /* Write the main out-decl state, followed by out-decl states of
1578      functions. */
1579   decl_state_stream = ((struct lto_output_stream *)
1580                        xcalloc (1, sizeof (struct lto_output_stream)));
1581   num_decl_states = num_fns + 1;
1582   lto_output_data_stream (decl_state_stream, &num_decl_states,
1583                           sizeof (num_decl_states));
1584   lto_output_decl_state_refs (ob, decl_state_stream, out_state);
1585   for (idx = 0; idx < num_fns; idx++)
1586     {
1587       fn_out_state =
1588         VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
1589       lto_output_decl_state_refs (ob, decl_state_stream, fn_out_state);
1590     }
1591   lto_write_stream (decl_state_stream);
1592   free(decl_state_stream);
1593
1594   lto_write_stream (ob->main_stream);
1595   lto_write_stream (ob->string_stream);
1596
1597   lto_end_section ();
1598
1599   /* Write the symbol table.  It is used by linker to determine dependencies
1600      and thus we can skip it for WPA.  */
1601   if (!flag_wpa)
1602     produce_symtab (ob, set, vset);
1603
1604   /* Write command line opts.  */
1605   lto_write_options ();
1606
1607   /* Deallocate memory and clean up.  */
1608   for (idx = 0; idx < num_fns; idx++)
1609     {
1610       fn_out_state =
1611         VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
1612       lto_delete_out_decl_state (fn_out_state);
1613     }
1614   lto_cgraph_encoder_delete (ob->decl_state->cgraph_node_encoder);
1615   lto_varpool_encoder_delete (ob->decl_state->varpool_node_encoder);
1616   VEC_free (lto_out_decl_state_ptr, heap, lto_function_decl_states);
1617   lto_function_decl_states = NULL;
1618   destroy_output_block (ob);
1619 }
1620
1621
1622 struct ipa_opt_pass_d pass_ipa_lto_finish_out =
1623 {
1624  {
1625   IPA_PASS,
1626   "lto_decls_out",                      /* name */
1627   gate_lto_out,                         /* gate */
1628   NULL,                                 /* execute */
1629   NULL,                                 /* sub */
1630   NULL,                                 /* next */
1631   0,                                    /* static_pass_number */
1632   TV_IPA_LTO_DECL_OUT,                  /* tv_id */
1633   0,                                    /* properties_required */
1634   0,                                    /* properties_provided */
1635   0,                                    /* properties_destroyed */
1636   0,                                    /* todo_flags_start */
1637   0                                     /* todo_flags_finish */
1638  },
1639  NULL,                                  /* generate_summary */
1640  produce_asm_for_decls,                 /* write_summary */
1641  NULL,                                  /* read_summary */
1642  produce_asm_for_decls,                 /* write_optimization_summary */
1643  NULL,                                  /* read_optimization_summary */
1644  NULL,                                  /* stmt_fixup */
1645  0,                                     /* TODOs */
1646  NULL,                                  /* function_transform */
1647  NULL                                   /* variable_transform */
1648 };