OSDN Git Service

2009-10-09 Richard Guenther <rguenther@suse.de>
[pf3gnuchains/gcc-fork.git] / gcc / lto-streamer-out.c
1 /* Write the GIMPLE representation to a file stream.
2
3    Copyright 2009 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 "toplev.h"
28 #include "tree.h"
29 #include "expr.h"
30 #include "flags.h"
31 #include "params.h"
32 #include "input.h"
33 #include "varray.h"
34 #include "hashtab.h"
35 #include "basic-block.h"
36 #include "tree-flow.h"
37 #include "tree-pass.h"
38 #include "cgraph.h"
39 #include "function.h"
40 #include "ggc.h"
41 #include "diagnostic.h"
42 #include "except.h"
43 #include "vec.h"
44 #include "lto-symtab.h"
45 #include "lto-streamer.h"
46
47
48 struct string_slot
49 {
50   const char *s;
51   int len;
52   unsigned int slot_num;
53 };
54
55
56 /* Returns a hash code for P.  */
57
58 static hashval_t
59 hash_string_slot_node (const void *p)
60 {
61   const struct string_slot *ds = (const struct string_slot *) p;
62   return (hashval_t) htab_hash_string (ds->s);
63 }
64
65
66 /* Returns nonzero if P1 and P2 are equal.  */
67
68 static int
69 eq_string_slot_node (const void *p1, const void *p2)
70 {
71   const struct string_slot *ds1 = (const struct string_slot *) p1;
72   const struct string_slot *ds2 = (const struct string_slot *) p2;
73
74   if (ds1->len == ds2->len)
75     {
76       int i;
77       for (i = 0; i < ds1->len; i++)
78         if (ds1->s[i] != ds2->s[i])
79           return 0;
80       return 1;
81     }
82
83   return 0;
84 }
85
86
87 /* Free the string slot pointed-to by P.  */
88
89 static void 
90 string_slot_free (void *p)
91 {
92   struct string_slot *slot = (struct string_slot *) p;
93   free (CONST_CAST (void *, (const void *) slot->s));
94   free (slot);
95 }
96
97
98 /* Clear the line info stored in DATA_IN.  */
99
100 static void
101 clear_line_info (struct output_block *ob)
102 {
103   ob->current_file = NULL;
104   ob->current_line = 0;
105   ob->current_col = 0;
106 }
107
108
109 /* Create the output block and return it.  SECTION_TYPE is
110    LTO_section_function_body or LTO_static_initializer.  */
111
112 struct output_block *
113 create_output_block (enum lto_section_type section_type)
114 {
115   struct output_block *ob = XCNEW (struct output_block);
116
117   ob->section_type = section_type;
118   ob->decl_state = lto_get_out_decl_state ();
119   ob->main_stream = XCNEW (struct lto_output_stream);
120   ob->string_stream = XCNEW (struct lto_output_stream);
121   ob->writer_cache = lto_streamer_cache_create ();
122
123   if (section_type == LTO_section_function_body)
124     ob->cfg_stream = XCNEW (struct lto_output_stream);
125
126   clear_line_info (ob);
127
128   ob->string_hash_table = htab_create (37, hash_string_slot_node,
129                                        eq_string_slot_node, string_slot_free);
130
131   return ob;
132 }
133
134
135 /* Destroy the output block OB.  */
136
137 void
138 destroy_output_block (struct output_block *ob)
139 {
140   enum lto_section_type section_type = ob->section_type;
141
142   htab_delete (ob->string_hash_table);
143
144   free (ob->main_stream);
145   free (ob->string_stream);
146   if (section_type == LTO_section_function_body)
147     free (ob->cfg_stream);
148
149   lto_streamer_cache_delete (ob->writer_cache);
150
151   free (ob);
152 }
153
154
155 /* Output bitpack BP to output stream S.  */
156
157 void
158 lto_output_bitpack (struct lto_output_stream *s, struct bitpack_d *bp)
159 {
160   unsigned i;
161   bitpack_word_t v;
162
163   lto_output_uleb128_stream (s, VEC_length (bitpack_word_t, bp->values));
164   for (i = 0; VEC_iterate (bitpack_word_t, bp->values, i, v); i++)
165     lto_output_uleb128_stream (s, v);
166 }
167
168
169 /* Output STRING of LEN characters to the string
170    table in OB. The string might or might not include a trailing '\0'.
171    Then put the index onto the INDEX_STREAM.  */
172
173 static void
174 output_string_with_length (struct output_block *ob,
175                            struct lto_output_stream *index_stream,
176                            const char *s,
177                            unsigned int len)
178 {
179   struct string_slot **slot;
180   struct string_slot s_slot;
181   char *string = (char *) xmalloc (len + 1);
182   memcpy (string, s, len);
183   string[len] = '\0';
184
185   s_slot.s = string;
186   s_slot.len = len;
187   s_slot.slot_num = 0;
188
189   slot = (struct string_slot **) htab_find_slot (ob->string_hash_table,
190                                                  &s_slot, INSERT);
191   if (*slot == NULL)
192     {
193       struct lto_output_stream *string_stream = ob->string_stream;
194       unsigned int start = string_stream->total_size;
195       struct string_slot *new_slot
196         = (struct string_slot *) xmalloc (sizeof (struct string_slot));
197       unsigned int i;
198
199       new_slot->s = string;
200       new_slot->len = len;
201       new_slot->slot_num = start;
202       *slot = new_slot;
203       lto_output_uleb128_stream (index_stream, start);
204       lto_output_uleb128_stream (string_stream, len);
205       for (i = 0; i < len; i++)
206         lto_output_1_stream (string_stream, string[i]);
207     }
208   else
209     {
210       struct string_slot *old_slot = (struct string_slot *)*slot;
211       lto_output_uleb128_stream (index_stream, old_slot->slot_num);
212       free (string);
213     }
214 }
215
216 /* Output the '\0' terminated STRING to the string
217    table in OB.  Then put the index onto the INDEX_STREAM.  */
218
219 static void
220 output_string (struct output_block *ob,
221                struct lto_output_stream *index_stream,
222                const char *string)
223 {
224   if (string)
225     {
226       lto_output_uleb128_stream (index_stream, 0);
227       output_string_with_length (ob, index_stream, string, strlen (string) + 1);
228     }
229   else
230     lto_output_uleb128_stream (index_stream, 1);
231 }
232
233
234 /* Output the STRING constant to the string
235    table in OB.  Then put the index onto the INDEX_STREAM.  */
236
237 static void
238 output_string_cst (struct output_block *ob,
239                    struct lto_output_stream *index_stream,
240                    tree string)
241 {
242   if (string)
243     {
244       lto_output_uleb128_stream (index_stream, 0);
245       output_string_with_length (ob, index_stream,
246                                  TREE_STRING_POINTER (string),
247                                  TREE_STRING_LENGTH (string));
248     }
249   else
250     lto_output_uleb128_stream (index_stream, 1);
251 }
252
253
254 /* Output the identifier ID to the string
255    table in OB.  Then put the index onto the INDEX_STREAM.  */
256
257 static void
258 output_identifier (struct output_block *ob,
259                    struct lto_output_stream *index_stream,
260                    tree id)
261 {
262   if (id)
263     {
264       lto_output_uleb128_stream (index_stream, 0);
265       output_string_with_length (ob, index_stream,
266                                  IDENTIFIER_POINTER (id),
267                                  IDENTIFIER_LENGTH (id));
268     }
269   else
270     lto_output_uleb128_stream (index_stream, 1);
271 }
272
273 /* Write a zero to the output stream.  */
274
275 static void
276 output_zero (struct output_block *ob)
277 {
278   lto_output_1_stream (ob->main_stream, 0);
279 }
280
281
282 /* Output an unsigned LEB128 quantity to OB->main_stream.  */
283
284 static void
285 output_uleb128 (struct output_block *ob, unsigned HOST_WIDE_INT work)
286 {
287   lto_output_uleb128_stream (ob->main_stream, work);
288 }
289
290
291 /* Output a signed LEB128 quantity to OB->main_stream.  */
292
293 static void
294 output_sleb128 (struct output_block *ob, HOST_WIDE_INT work)
295 {
296   lto_output_sleb128_stream (ob->main_stream, work);
297 }
298
299
300 /* Output the start of a record with TAG to output block OB.  */
301
302 static void
303 output_record_start (struct output_block *ob, enum LTO_tags tag)
304 {
305   /* Make sure TAG fits inside an unsigned int.  */
306   gcc_assert (tag == (enum LTO_tags) (unsigned) tag);
307   output_uleb128 (ob, tag);
308 }
309
310
311 /* Look up NODE in the type table and write the index for it to OB.  */
312
313 static void
314 output_type_ref (struct output_block *ob, tree node)
315 {
316   output_record_start (ob, LTO_type_ref);
317   lto_output_type_ref_index (ob->decl_state, ob->main_stream, node);
318 }
319
320
321 /* Pack all the non-pointer fields of the TS_BASE structure of
322    expression EXPR into bitpack BP.  */
323
324 static void
325 pack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
326 {
327   bp_pack_value (bp, TREE_CODE (expr), 16);
328   if (!TYPE_P (expr))
329     {
330       bp_pack_value (bp, TREE_SIDE_EFFECTS (expr), 1);
331       bp_pack_value (bp, TREE_CONSTANT (expr), 1);
332       bp_pack_value (bp, TREE_READONLY (expr), 1);
333
334       /* TREE_PUBLIC is used on types to indicate that the type
335          has a TYPE_CACHED_VALUES vector.  This is not streamed out,
336          so we skip it here.  */
337       bp_pack_value (bp, TREE_PUBLIC (expr), 1);
338     }
339   bp_pack_value (bp, TREE_ADDRESSABLE (expr), 1);
340   bp_pack_value (bp, TREE_THIS_VOLATILE (expr), 1);
341   if (DECL_P (expr))
342     bp_pack_value (bp, DECL_UNSIGNED (expr), 1);
343   else if (TYPE_P (expr))
344     bp_pack_value (bp, TYPE_UNSIGNED (expr), 1);
345   bp_pack_value (bp, TREE_ASM_WRITTEN (expr), 1);
346   bp_pack_value (bp, TREE_NO_WARNING (expr), 1);
347   bp_pack_value (bp, TREE_USED (expr), 1);
348   bp_pack_value (bp, TREE_NOTHROW (expr), 1);
349   bp_pack_value (bp, TREE_STATIC (expr), 1);
350   bp_pack_value (bp, TREE_PRIVATE (expr), 1);
351   bp_pack_value (bp, TREE_PROTECTED (expr), 1);
352   bp_pack_value (bp, TREE_DEPRECATED (expr), 1);
353   if (TYPE_P (expr))
354     bp_pack_value (bp, TYPE_SATURATING (expr), 1);
355   if (TREE_CODE (expr) == SSA_NAME)
356     bp_pack_value (bp, SSA_NAME_IS_DEFAULT_DEF (expr), 1);
357 }
358
359
360 /* Pack all the non-pointer fields of the TS_REAL_CST structure of
361    expression EXPR into bitpack BP.  */
362
363 static void
364 pack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
365 {
366   unsigned i;
367   REAL_VALUE_TYPE r;
368   
369   r = TREE_REAL_CST (expr);
370   bp_pack_value (bp, r.cl, 2);
371   bp_pack_value (bp, r.decimal, 1);
372   bp_pack_value (bp, r.sign, 1);
373   bp_pack_value (bp, r.signalling, 1);
374   bp_pack_value (bp, r.canonical, 1);
375   bp_pack_value (bp, r.uexp, EXP_BITS);
376   for (i = 0; i < SIGSZ; i++)
377     bp_pack_value (bp, r.sig[i], HOST_BITS_PER_LONG);
378 }
379
380
381 /* Pack all the non-pointer fields of the TS_FIXED_CST structure of
382    expression EXPR into bitpack BP.  */
383
384 static void
385 pack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr)
386 {
387   struct fixed_value fv = TREE_FIXED_CST (expr);
388   bp_pack_value (bp, fv.data.low, HOST_BITS_PER_WIDE_INT);
389   bp_pack_value (bp, fv.data.high, HOST_BITS_PER_WIDE_INT);
390 }
391
392
393 /* Pack all the non-pointer fields of the TS_DECL_COMMON structure
394    of expression EXPR into bitpack BP.  */
395
396 static void
397 pack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr)
398 {
399   bp_pack_value (bp, DECL_MODE (expr), 8);
400   bp_pack_value (bp, DECL_NONLOCAL (expr), 1);
401   bp_pack_value (bp, DECL_VIRTUAL_P (expr), 1);
402   bp_pack_value (bp, DECL_IGNORED_P (expr), 1);
403   bp_pack_value (bp, DECL_ABSTRACT (expr), 1);
404   bp_pack_value (bp, DECL_ARTIFICIAL (expr), 1);
405   bp_pack_value (bp, DECL_USER_ALIGN (expr), 1);
406   bp_pack_value (bp, DECL_PRESERVE_P (expr), 1);
407   bp_pack_value (bp, DECL_DEBUG_EXPR_IS_FROM (expr), 1);
408   bp_pack_value (bp, DECL_EXTERNAL (expr), 1);
409   bp_pack_value (bp, DECL_GIMPLE_REG_P (expr), 1);
410   bp_pack_value (bp, DECL_ALIGN (expr), HOST_BITS_PER_INT);
411
412   if (TREE_CODE (expr) == LABEL_DECL)
413     {
414       /* Note that we do not write LABEL_DECL_UID.  The reader will
415          always assume an initial value of -1 so that the
416          label_to_block_map is recreated by gimple_set_bb.  */
417       bp_pack_value (bp, DECL_ERROR_ISSUED (expr), 1);
418       bp_pack_value (bp, EH_LANDING_PAD_NR (expr), HOST_BITS_PER_INT);
419     }
420
421   if (TREE_CODE (expr) == FIELD_DECL)
422     {
423       bp_pack_value (bp, DECL_PACKED (expr), 1);
424       bp_pack_value (bp, DECL_NONADDRESSABLE_P (expr), 1);
425       bp_pack_value (bp, DECL_OFFSET_ALIGN (expr), 8);
426     }
427
428   if (TREE_CODE (expr) == RESULT_DECL
429       || TREE_CODE (expr) == PARM_DECL
430       || TREE_CODE (expr) == VAR_DECL)
431     {
432       bp_pack_value (bp, DECL_BY_REFERENCE (expr), 1);
433       if (TREE_CODE (expr) == VAR_DECL
434           || TREE_CODE (expr) == PARM_DECL)
435         bp_pack_value (bp, DECL_HAS_VALUE_EXPR_P (expr), 1);
436     }
437 }
438
439
440 /* Pack all the non-pointer fields of the TS_DECL_WRTL structure
441    of expression EXPR into bitpack BP.  */
442
443 static void
444 pack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
445 {
446   bp_pack_value (bp, DECL_REGISTER (expr), 1);
447 }
448
449
450 /* Pack all the non-pointer fields of the TS_DECL_WITH_VIS structure
451    of expression EXPR into bitpack BP.  */
452
453 static void
454 pack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
455 {
456   bp_pack_value (bp, DECL_DEFER_OUTPUT (expr), 1);
457   bp_pack_value (bp, DECL_COMMON (expr), 1);
458   bp_pack_value (bp, DECL_DLLIMPORT_P (expr), 1);
459   bp_pack_value (bp, DECL_WEAK (expr), 1);
460   bp_pack_value (bp, DECL_SEEN_IN_BIND_EXPR_P (expr),  1);
461   bp_pack_value (bp, DECL_COMDAT (expr),  1);
462   bp_pack_value (bp, DECL_VISIBILITY (expr),  2);
463   bp_pack_value (bp, DECL_VISIBILITY_SPECIFIED (expr),  1);
464
465   if (TREE_CODE (expr) == VAR_DECL)
466     {
467       bp_pack_value (bp, DECL_HARD_REGISTER (expr), 1);
468       bp_pack_value (bp, DECL_IN_TEXT_SECTION (expr), 1);
469       bp_pack_value (bp, DECL_TLS_MODEL (expr),  3);
470     }
471
472   if (VAR_OR_FUNCTION_DECL_P (expr))
473     bp_pack_value (bp, DECL_INIT_PRIORITY (expr), HOST_BITS_PER_SHORT);
474 }
475
476
477 /* Pack all the non-pointer fields of the TS_FUNCTION_DECL structure
478    of expression EXPR into bitpack BP.  */
479
480 static void
481 pack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
482 {
483   /* For normal/md builtins we only write the class and code, so they
484      should never be handled here.  */
485   gcc_assert (!lto_stream_as_builtin_p (expr));
486
487   bp_pack_value (bp, DECL_FUNCTION_CODE (expr), 11);
488   bp_pack_value (bp, DECL_BUILT_IN_CLASS (expr), 2);
489   bp_pack_value (bp, DECL_STATIC_CONSTRUCTOR (expr), 1);
490   bp_pack_value (bp, DECL_STATIC_DESTRUCTOR (expr), 1);
491   bp_pack_value (bp, DECL_UNINLINABLE (expr), 1);
492   bp_pack_value (bp, DECL_POSSIBLY_INLINED (expr), 1);
493   bp_pack_value (bp, DECL_IS_NOVOPS (expr), 1);
494   bp_pack_value (bp, DECL_IS_RETURNS_TWICE (expr), 1);
495   bp_pack_value (bp, DECL_IS_MALLOC (expr), 1);
496   bp_pack_value (bp, DECL_IS_OPERATOR_NEW (expr), 1);
497   bp_pack_value (bp, DECL_DECLARED_INLINE_P (expr), 1);
498   bp_pack_value (bp, DECL_STATIC_CHAIN (expr), 1);
499   bp_pack_value (bp, DECL_NO_INLINE_WARNING_P (expr), 1);
500   bp_pack_value (bp, DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr), 1);
501   bp_pack_value (bp, DECL_NO_LIMIT_STACK (expr), 1);
502   bp_pack_value (bp, DECL_DISREGARD_INLINE_LIMITS (expr), 1);
503   bp_pack_value (bp, DECL_PURE_P (expr), 1);
504   bp_pack_value (bp, DECL_LOOPING_CONST_OR_PURE_P (expr), 1);
505 }
506
507
508 /* Pack all the non-pointer fields of the TS_TYPE structure
509    of expression EXPR into bitpack BP.  */
510
511 static void
512 pack_ts_type_value_fields (struct bitpack_d *bp, tree expr)
513 {
514   bp_pack_value (bp, TYPE_PRECISION (expr), 9);
515   bp_pack_value (bp, TYPE_MODE (expr), 7);
516   bp_pack_value (bp, TYPE_STRING_FLAG (expr), 1);
517   bp_pack_value (bp, TYPE_NO_FORCE_BLK (expr), 1);
518   bp_pack_value (bp, TYPE_NEEDS_CONSTRUCTING(expr), 1);
519   if (TREE_CODE (expr) == UNION_TYPE)
520     bp_pack_value (bp, TYPE_TRANSPARENT_UNION (expr), 1);
521   bp_pack_value (bp, TYPE_PACKED (expr), 1);
522   bp_pack_value (bp, TYPE_RESTRICT (expr), 1);
523   bp_pack_value (bp, TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr), 2);
524   bp_pack_value (bp, TYPE_USER_ALIGN (expr), 1);
525   bp_pack_value (bp, TYPE_READONLY (expr), 1);
526   bp_pack_value (bp, TYPE_ALIGN (expr), HOST_BITS_PER_INT);
527   bp_pack_value (bp, TYPE_ALIAS_SET (expr) == 0 ? 0 : -1, HOST_BITS_PER_INT);
528 }
529
530
531 /* Pack all the non-pointer fields of the TS_BLOCK structure
532    of expression EXPR into bitpack BP.  */
533
534 static void
535 pack_ts_block_value_fields (struct bitpack_d *bp, tree expr)
536 {
537   bp_pack_value (bp, BLOCK_ABSTRACT (expr), 1);
538   bp_pack_value (bp, BLOCK_NUMBER (expr), 31);
539 }
540
541
542 /* Pack all the non-pointer fields in EXPR into a bit pack.  */
543
544 static struct bitpack_d *
545 pack_value_fields (tree expr)
546 {
547   enum tree_code code;
548   struct bitpack_d *bp;
549
550   code = TREE_CODE (expr);
551   bp = bitpack_create ();
552
553   /* Note that all these functions are highly sensitive to changes in
554      the types and sizes of each of the fields being packed.  */
555   pack_ts_base_value_fields (bp, expr);
556
557   if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
558     pack_ts_real_cst_value_fields (bp, expr);
559
560   if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
561     pack_ts_fixed_cst_value_fields (bp, expr);
562
563   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
564     pack_ts_decl_common_value_fields (bp, expr);
565
566   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
567     pack_ts_decl_wrtl_value_fields (bp, expr);
568
569   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
570     pack_ts_decl_with_vis_value_fields (bp, expr);
571
572   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
573     pack_ts_function_decl_value_fields (bp, expr);
574
575   if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
576     pack_ts_type_value_fields (bp, expr);
577
578   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
579     pack_ts_block_value_fields (bp, expr);
580
581   if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
582     {
583       /* We only stream the version number of SSA names.  */
584       gcc_unreachable ();
585     }
586
587   if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
588     {
589       /* This is only used by GENERIC.  */
590       gcc_unreachable ();
591     }
592
593   if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
594     {
595       /* This is only used by High GIMPLE.  */
596       gcc_unreachable ();
597     }
598
599   return bp;
600 }
601
602
603 /* Emit location LOC to output block OB.  */
604
605 static void
606 lto_output_location (struct output_block *ob, location_t loc)
607 {
608   expanded_location xloc;
609
610   if (loc == UNKNOWN_LOCATION)
611     {
612       output_string (ob, ob->main_stream, NULL);
613       return;
614     }
615
616   xloc = expand_location (loc);
617
618   output_string (ob, ob->main_stream, xloc.file);
619   output_sleb128 (ob, xloc.line);
620   output_sleb128 (ob, xloc.column);
621
622   ob->current_file = xloc.file;
623   ob->current_line = xloc.line;
624   ob->current_col = xloc.column;
625 }
626
627
628 /* Return true if tree node T is written to various tables.  For these
629    nodes, we sometimes want to write their phyiscal representation
630    (via lto_output_tree), and sometimes we need to emit an index
631    reference into a table (via lto_output_tree_ref).  */
632
633 static bool
634 tree_is_indexable (tree t)
635 {
636   if (TREE_CODE (t) == PARM_DECL)
637     return false;
638   else if (TREE_CODE (t) == VAR_DECL && decl_function_context (t))
639     return false;
640   else
641     return (TYPE_P (t) || DECL_P (t) || TREE_CODE (t) == SSA_NAME);
642 }
643
644
645 /* If EXPR is an indexable tree node, output a reference to it to
646    output block OB.  Otherwise, output the physical representation of
647    EXPR to OB.  */
648
649 static void
650 lto_output_tree_ref (struct output_block *ob, tree expr)
651 {
652   enum tree_code code;
653
654   if (expr == NULL_TREE)
655     {
656       output_zero (ob);
657       return;
658     }
659
660   if (!tree_is_indexable (expr))
661     {
662       /* Even though we are emitting the physical representation of
663          EXPR, its leaves must be emitted as references.  */
664       lto_output_tree (ob, expr, true);
665       return;
666     }
667
668   if (TYPE_P (expr))
669     {
670       output_type_ref (ob, expr);
671       return;
672     }
673
674   code = TREE_CODE (expr);
675   switch (code)
676     {
677     case SSA_NAME:
678       output_record_start (ob, LTO_ssa_name_ref);
679       output_uleb128 (ob, SSA_NAME_VERSION (expr));
680       break;
681
682     case FIELD_DECL:
683       output_record_start (ob, LTO_field_decl_ref);
684       lto_output_field_decl_index (ob->decl_state, ob->main_stream, expr);
685       break;
686
687     case FUNCTION_DECL:
688       output_record_start (ob, LTO_function_decl_ref);
689       lto_output_fn_decl_index (ob->decl_state, ob->main_stream, expr);
690       break;
691
692     case VAR_DECL:
693       gcc_assert (decl_function_context (expr) == NULL);
694       output_record_start (ob, LTO_global_decl_ref);
695       lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
696       break;
697
698     case CONST_DECL:
699       output_record_start (ob, LTO_const_decl_ref);
700       lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
701       break;
702
703     case IMPORTED_DECL:
704       gcc_assert (decl_function_context (expr) == NULL);
705       output_record_start (ob, LTO_imported_decl_ref);
706       lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
707       break;
708
709     case TYPE_DECL:
710       output_record_start (ob, LTO_type_decl_ref);
711       lto_output_type_decl_index (ob->decl_state, ob->main_stream, expr);
712       break;
713
714     case NAMESPACE_DECL:
715       output_record_start (ob, LTO_namespace_decl_ref);
716       lto_output_namespace_decl_index (ob->decl_state, ob->main_stream, expr);
717       break;
718
719     case LABEL_DECL:
720       output_record_start (ob, LTO_label_decl_ref);
721       lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
722       break;
723
724     case RESULT_DECL:
725       output_record_start (ob, LTO_result_decl_ref);
726       lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr);
727       break;
728
729     default:
730       /* No other node is indexable, so it should have been handled
731          by lto_output_tree.  */
732       gcc_unreachable ();
733     }
734 }
735
736
737 /* If REF_P is true, emit a reference to EXPR in output block OB,
738    otherwise emit the physical representation of EXPR in OB.  */
739
740 static inline void
741 lto_output_tree_or_ref (struct output_block *ob, tree expr, bool ref_p)
742 {
743   if (ref_p)
744     lto_output_tree_ref (ob, expr);
745   else
746     lto_output_tree (ob, expr, false);
747 }
748
749
750 /* Emit the chain of tree nodes starting at T.  OB is the output block
751    to write to.  REF_P is true if chain elements should be emitted
752    as references.  */
753
754 static void
755 lto_output_chain (struct output_block *ob, tree t, bool ref_p)
756 {
757   int i, count;
758   
759   count = list_length (t);
760   output_sleb128 (ob, count);
761   for (i = 0; i < count; i++)
762     {
763       tree saved_chain;
764
765       /* Clear TREE_CHAIN to avoid blindly recursing into the rest
766          of the list.  */
767       saved_chain = TREE_CHAIN (t);
768       TREE_CHAIN (t) = NULL_TREE;
769
770       lto_output_tree_or_ref (ob, t, ref_p);
771
772       TREE_CHAIN (t) = saved_chain;
773       t = TREE_CHAIN (t);
774     }
775 }
776
777
778 /* Write all pointer fields in the TS_COMMON structure of EXPR to output
779    block OB.  If REF_P is true, write a reference to EXPR's pointer
780    fields.  */
781
782 static void
783 lto_output_ts_common_tree_pointers (struct output_block *ob, tree expr,
784                                     bool ref_p)
785 {
786   lto_output_tree_or_ref (ob, TREE_TYPE (expr), ref_p);
787 }
788
789
790 /* Write all pointer fields in the TS_VECTOR structure of EXPR to output
791    block OB.  If REF_P is true, write a reference to EXPR's pointer
792    fields.  */
793
794 static void
795 lto_output_ts_vector_tree_pointers (struct output_block *ob, tree expr,
796                                     bool ref_p)
797 {
798   lto_output_chain (ob, TREE_VECTOR_CST_ELTS (expr), ref_p);
799 }
800
801
802 /* Write all pointer fields in the TS_COMPLEX structure of EXPR to output
803    block OB.  If REF_P is true, write a reference to EXPR's pointer
804    fields.  */
805
806 static void
807 lto_output_ts_complex_tree_pointers (struct output_block *ob, tree expr,
808                                      bool ref_p)
809 {
810   lto_output_tree_or_ref (ob, TREE_REALPART (expr), ref_p);
811   lto_output_tree_or_ref (ob, TREE_IMAGPART (expr), ref_p);
812 }
813
814
815 /* Write all pointer fields in the TS_DECL_MINIMAL structure of EXPR
816    to output block OB.  If REF_P is true, write a reference to EXPR's
817    pointer fields.  */
818
819 static void
820 lto_output_ts_decl_minimal_tree_pointers (struct output_block *ob, tree expr,
821                                           bool ref_p)
822 {
823   lto_output_tree_or_ref (ob, DECL_NAME (expr), ref_p);
824   lto_output_tree_or_ref (ob, DECL_CONTEXT (expr), ref_p);
825   lto_output_location (ob, DECL_SOURCE_LOCATION (expr));
826 }
827
828
829 /* Write all pointer fields in the TS_DECL_COMMON structure of EXPR to
830    output block OB.  If REF_P is true, write a reference to EXPR's
831    pointer fields.  */
832
833 static void
834 lto_output_ts_decl_common_tree_pointers (struct output_block *ob, tree expr,
835                                          bool ref_p)
836 {
837   lto_output_tree_or_ref (ob, DECL_SIZE (expr), ref_p);
838   lto_output_tree_or_ref (ob, DECL_SIZE_UNIT (expr), ref_p);
839
840   if (TREE_CODE (expr) != FUNCTION_DECL)
841     lto_output_tree_or_ref (ob, DECL_INITIAL (expr), ref_p);
842
843   lto_output_tree_or_ref (ob, DECL_ATTRIBUTES (expr), ref_p);
844   lto_output_tree_or_ref (ob, DECL_ABSTRACT_ORIGIN (expr), ref_p);
845
846   if (TREE_CODE (expr) == PARM_DECL)
847     lto_output_chain (ob, TREE_CHAIN (expr), ref_p);
848 }
849
850
851 /* Write all pointer fields in the TS_DECL_NON_COMMON structure of
852    EXPR to output block OB.  If REF_P is true, write a reference to EXPR's
853    pointer fields.  */
854
855 static void
856 lto_output_ts_decl_non_common_tree_pointers (struct output_block *ob,
857                                              tree expr, bool ref_p)
858 {
859   if (TREE_CODE (expr) == FUNCTION_DECL)
860     {
861       /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
862          At this point, it should not exist.  Either because it was
863          converted to gimple or because DECL didn't have a GENERIC
864          representation in this TU.  */
865       gcc_assert (DECL_SAVED_TREE (expr) == NULL_TREE);
866       lto_output_tree_or_ref (ob, DECL_ARGUMENTS (expr), ref_p);
867       lto_output_tree_or_ref (ob, DECL_RESULT (expr), ref_p);
868     }
869   lto_output_tree_or_ref (ob, DECL_VINDEX (expr), ref_p);
870 }
871
872
873 /* Write all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
874    to output block OB.  If REF_P is true, write a reference to EXPR's
875    pointer fields.  */
876
877 static void
878 lto_output_ts_decl_with_vis_tree_pointers (struct output_block *ob, tree expr,
879                                            bool ref_p)
880 {
881   /* Make sure we don't inadvertently set the assembler name.  */
882   if (DECL_ASSEMBLER_NAME_SET_P (expr))
883     lto_output_tree_or_ref (ob, DECL_ASSEMBLER_NAME (expr), ref_p);
884   else
885     output_zero (ob);
886
887   lto_output_tree_or_ref (ob, DECL_SECTION_NAME (expr), ref_p);
888   lto_output_tree_or_ref (ob, DECL_COMDAT_GROUP (expr), ref_p);
889 }
890
891
892 /* Write all pointer fields in the TS_FIELD_DECL structure of EXPR to
893    output block OB.  If REF_P is true, write a reference to EXPR's
894    pointer fields.  */
895
896 static void
897 lto_output_ts_field_decl_tree_pointers (struct output_block *ob, tree expr,
898                                         bool ref_p)
899 {
900   lto_output_tree_or_ref (ob, DECL_FIELD_OFFSET (expr), ref_p);
901   lto_output_tree_or_ref (ob, DECL_BIT_FIELD_TYPE (expr), ref_p);
902   lto_output_tree_or_ref (ob, DECL_QUALIFIER (expr), ref_p);
903   lto_output_tree_or_ref (ob, DECL_FIELD_BIT_OFFSET (expr), ref_p);
904   lto_output_tree_or_ref (ob, DECL_FCONTEXT (expr), ref_p);
905   lto_output_chain (ob, TREE_CHAIN (expr), ref_p);
906 }
907
908
909 /* Write all pointer fields in the TS_FUNCTION_DECL structure of EXPR
910    to output block OB.  If REF_P is true, write a reference to EXPR's
911    pointer fields.  */
912
913 static void
914 lto_output_ts_function_decl_tree_pointers (struct output_block *ob, tree expr,
915                                            bool ref_p)
916 {
917   /* DECL_STRUCT_FUNCTION is handled by lto_output_function.  FIXME lto,
918      maybe it should be handled here?  */
919   lto_output_tree_or_ref (ob, DECL_FUNCTION_PERSONALITY (expr), ref_p);
920   lto_output_tree_or_ref (ob, DECL_FUNCTION_SPECIFIC_TARGET (expr), ref_p);
921   lto_output_tree_or_ref (ob, DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr),
922                           ref_p);
923 }
924
925
926 /* Write all pointer fields in the TS_TYPE structure of EXPR to output
927    block OB.  If REF_P is true, write a reference to EXPR's pointer
928    fields.  */
929
930 static void
931 lto_output_ts_type_tree_pointers (struct output_block *ob, tree expr,
932                                   bool ref_p)
933 {
934   if (TREE_CODE (expr) == ENUMERAL_TYPE)
935     lto_output_tree_or_ref (ob, TYPE_VALUES (expr), ref_p);
936   else if (TREE_CODE (expr) == ARRAY_TYPE)
937     lto_output_tree_or_ref (ob, TYPE_DOMAIN (expr), ref_p);
938   else if (TREE_CODE (expr) == RECORD_TYPE || TREE_CODE (expr) == UNION_TYPE)
939     lto_output_tree_or_ref (ob, TYPE_FIELDS (expr), ref_p);
940   else if (TREE_CODE (expr) == FUNCTION_TYPE || TREE_CODE (expr) == METHOD_TYPE)
941     lto_output_tree_or_ref (ob, TYPE_ARG_TYPES (expr), ref_p);
942   else if (TREE_CODE (expr) == VECTOR_TYPE)
943     lto_output_tree_or_ref (ob, TYPE_DEBUG_REPRESENTATION_TYPE (expr), ref_p);
944
945   lto_output_tree_or_ref (ob, TYPE_SIZE (expr), ref_p);
946   lto_output_tree_or_ref (ob, TYPE_SIZE_UNIT (expr), ref_p);
947   lto_output_tree_or_ref (ob, TYPE_ATTRIBUTES (expr), ref_p);
948   lto_output_tree_or_ref (ob, TYPE_NAME (expr), ref_p);
949   /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO nor
950      TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO.  */
951   if (!POINTER_TYPE_P (expr))
952     lto_output_tree_or_ref (ob, TYPE_MINVAL (expr), ref_p);
953   lto_output_tree_or_ref (ob, TYPE_MAXVAL (expr), ref_p);
954   lto_output_tree_or_ref (ob, TYPE_MAIN_VARIANT (expr), ref_p);
955   /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
956      during fixup.  */
957   if (TREE_CODE (expr) == RECORD_TYPE || TREE_CODE (expr) == UNION_TYPE)
958     lto_output_tree_or_ref (ob, TYPE_BINFO (expr), ref_p);
959   lto_output_tree_or_ref (ob, TYPE_CONTEXT (expr), ref_p);
960   lto_output_tree_or_ref (ob, TYPE_CANONICAL (expr), ref_p);
961 }
962
963
964 /* Write all pointer fields in the TS_LIST structure of EXPR to output
965    block OB.  If REF_P is true, write a reference to EXPR's pointer
966    fields.  */
967
968 static void
969 lto_output_ts_list_tree_pointers (struct output_block *ob, tree expr,
970                                   bool ref_p)
971 {
972   lto_output_tree_or_ref (ob, TREE_PURPOSE (expr), ref_p);
973   lto_output_tree_or_ref (ob, TREE_VALUE (expr), ref_p);
974   lto_output_chain (ob, TREE_CHAIN (expr), ref_p);
975 }
976
977
978 /* Write all pointer fields in the TS_VEC structure of EXPR to output
979    block OB.  If REF_P is true, write a reference to EXPR's pointer
980    fields.  */
981
982 static void
983 lto_output_ts_vec_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
984 {
985   int i;
986
987   /* Note that the number of slots for EXPR has already been emitted
988      in EXPR's header (see lto_output_tree_header).  */
989   for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
990     lto_output_tree_or_ref (ob, TREE_VEC_ELT (expr, i), ref_p);
991 }
992
993
994 /* Write all pointer fields in the TS_EXP structure of EXPR to output
995    block OB.  If REF_P is true, write a reference to EXPR's pointer
996    fields.  */
997
998 static void
999 lto_output_ts_exp_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
1000 {
1001   int i;
1002
1003   output_sleb128 (ob, TREE_OPERAND_LENGTH (expr));
1004   for (i = 0; i < TREE_OPERAND_LENGTH (expr); i++)
1005     lto_output_tree_or_ref (ob, TREE_OPERAND (expr, i), ref_p);
1006   lto_output_location (ob, EXPR_LOCATION (expr));
1007   lto_output_tree_or_ref (ob, TREE_BLOCK (expr), ref_p);
1008 }
1009
1010
1011 /* Write all pointer fields in the TS_BLOCK structure of EXPR to output
1012    block OB.  If REF_P is true, write a reference to EXPR's pointer
1013    fields.  */
1014
1015 static void
1016 lto_output_ts_block_tree_pointers (struct output_block *ob, tree expr,
1017                                    bool ref_p)
1018 {
1019   unsigned i;
1020   tree t;
1021
1022   lto_output_location (ob, BLOCK_SOURCE_LOCATION (expr));
1023   lto_output_chain (ob, BLOCK_VARS (expr), ref_p);
1024
1025   output_uleb128 (ob, VEC_length (tree, BLOCK_NONLOCALIZED_VARS (expr)));
1026   for (i = 0; VEC_iterate (tree, BLOCK_NONLOCALIZED_VARS (expr), i, t); i++)
1027     lto_output_tree_or_ref (ob, t, ref_p);
1028
1029   lto_output_tree_or_ref (ob, BLOCK_SUPERCONTEXT (expr), ref_p);
1030   lto_output_tree_or_ref (ob, BLOCK_ABSTRACT_ORIGIN (expr), ref_p);
1031   lto_output_tree_or_ref (ob, BLOCK_FRAGMENT_ORIGIN (expr), ref_p);
1032   lto_output_tree_or_ref (ob, BLOCK_FRAGMENT_CHAIN (expr), ref_p);
1033   lto_output_chain (ob, BLOCK_SUBBLOCKS (expr), ref_p);
1034 }
1035
1036
1037 /* Write all pointer fields in the TS_BINFO structure of EXPR to output
1038    block OB.  If REF_P is true, write a reference to EXPR's pointer
1039    fields.  */
1040
1041 static void
1042 lto_output_ts_binfo_tree_pointers (struct output_block *ob, tree expr,
1043                                    bool ref_p)
1044 {
1045   unsigned i;
1046   tree t;
1047
1048   /* Note that the number of BINFO slots has already been emitted in
1049      EXPR's header (see lto_output_tree_header) because this length
1050      is needed to build the empty BINFO node on the reader side.  */
1051   for (i = 0; VEC_iterate (tree, BINFO_BASE_BINFOS (expr), i, t); i++)
1052     lto_output_tree_or_ref (ob, t, ref_p);
1053   output_zero (ob);
1054
1055   lto_output_tree_or_ref (ob, BINFO_OFFSET (expr), ref_p);
1056   lto_output_tree_or_ref (ob, BINFO_VTABLE (expr), ref_p);
1057   lto_output_tree_or_ref (ob, BINFO_VIRTUALS (expr), ref_p);
1058   lto_output_tree_or_ref (ob, BINFO_VPTR_FIELD (expr), ref_p);
1059
1060   output_uleb128 (ob, VEC_length (tree, BINFO_BASE_ACCESSES (expr)));
1061   for (i = 0; VEC_iterate (tree, BINFO_BASE_ACCESSES (expr), i, t); i++)
1062     lto_output_tree_or_ref (ob, t, ref_p);
1063
1064   lto_output_tree_or_ref (ob, BINFO_INHERITANCE_CHAIN (expr), ref_p);
1065   lto_output_tree_or_ref (ob, BINFO_SUBVTT_INDEX (expr), ref_p);
1066   lto_output_tree_or_ref (ob, BINFO_VPTR_INDEX (expr), ref_p);
1067 }
1068
1069
1070 /* Write all pointer fields in the TS_CONSTRUCTOR structure of EXPR to
1071    output block OB.  If REF_P is true, write a reference to EXPR's
1072    pointer fields.  */
1073
1074 static void
1075 lto_output_ts_constructor_tree_pointers (struct output_block *ob, tree expr,
1076                                          bool ref_p)
1077 {
1078   unsigned i;
1079   tree index, value;
1080
1081   output_uleb128 (ob, CONSTRUCTOR_NELTS (expr));
1082   FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value)
1083     {
1084       lto_output_tree_or_ref (ob, index, ref_p);
1085       lto_output_tree_or_ref (ob, value, ref_p);
1086     }
1087 }
1088
1089
1090 /* Helper for lto_output_tree.  Write all pointer fields in EXPR to output
1091    block OB.  If REF_P is true, the leaves of EXPR are emitted as
1092    references.  */
1093
1094 static void
1095 lto_output_tree_pointers (struct output_block *ob, tree expr, bool ref_p)
1096 {
1097   enum tree_code code;
1098
1099   code = TREE_CODE (expr);
1100
1101   if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
1102     lto_output_ts_common_tree_pointers (ob, expr, ref_p);
1103
1104   if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
1105     lto_output_ts_vector_tree_pointers (ob, expr, ref_p);
1106
1107   if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
1108     lto_output_ts_complex_tree_pointers (ob, expr, ref_p);
1109
1110   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
1111     lto_output_ts_decl_minimal_tree_pointers (ob, expr, ref_p);
1112
1113   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1114     lto_output_ts_decl_common_tree_pointers (ob, expr, ref_p);
1115
1116   if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
1117     lto_output_ts_decl_non_common_tree_pointers (ob, expr, ref_p);
1118
1119   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
1120     lto_output_ts_decl_with_vis_tree_pointers (ob, expr, ref_p);
1121
1122   if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
1123     lto_output_ts_field_decl_tree_pointers (ob, expr, ref_p);
1124
1125   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
1126     lto_output_ts_function_decl_tree_pointers (ob, expr, ref_p);
1127
1128   if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
1129     lto_output_ts_type_tree_pointers (ob, expr, ref_p);
1130
1131   if (CODE_CONTAINS_STRUCT (code, TS_LIST))
1132     lto_output_ts_list_tree_pointers (ob, expr, ref_p);
1133
1134   if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1135     lto_output_ts_vec_tree_pointers (ob, expr, ref_p);
1136
1137   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
1138     lto_output_ts_exp_tree_pointers (ob, expr, ref_p);
1139
1140   if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
1141     {
1142       /* We only stream the version number of SSA names.  */
1143       gcc_unreachable ();
1144     }
1145
1146   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
1147     lto_output_ts_block_tree_pointers (ob, expr, ref_p);
1148
1149   if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1150     lto_output_ts_binfo_tree_pointers (ob, expr, ref_p);
1151
1152   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
1153     lto_output_ts_constructor_tree_pointers (ob, expr, ref_p);
1154
1155   if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
1156     {
1157       /* This should only appear in GENERIC.  */
1158       gcc_unreachable ();
1159     }
1160
1161   if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
1162     {
1163       /* This should only appear in High GIMPLE.  */
1164       gcc_unreachable ();
1165     }
1166
1167   if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
1168     sorry ("gimple bytecode streams do not support the optimization attribute");
1169
1170   if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
1171     sorry ("gimple bytecode streams do not support the target attribute");
1172 }
1173
1174
1175 /* Emit header information for tree EXPR to output block OB.  The header
1176    contains everything needed to instantiate an empty skeleton for
1177    EXPR on the reading side.  IX is the index into the streamer cache
1178    where EXPR is stored.  REF_P is as in lto_output_tree.  */
1179
1180 static void
1181 lto_output_tree_header (struct output_block *ob, tree expr, int ix)
1182 {
1183   enum LTO_tags tag;
1184   enum tree_code code;
1185
1186   /* We should not see any non-GIMPLE tree nodes here.  */
1187   code = TREE_CODE (expr);
1188   if (!lto_is_streamable (expr))
1189     internal_error ("tree code %qs is not supported in gimple streams",
1190                     tree_code_name[code]);
1191
1192   /* The header of a tree node consists of its tag, the size of
1193      the node, and any other information needed to instantiate
1194      EXPR on the reading side (such as the number of slots in
1195      variable sized nodes).  */
1196   tag = lto_tree_code_to_tag (code);
1197   output_record_start (ob, tag);
1198   output_sleb128 (ob, ix);
1199
1200   /* The following will cause bootstrap miscomparisons.  Enable with care.  */
1201 #ifdef LTO_STREAMER_DEBUG
1202   /* This is used mainly for debugging purposes.  When the reader
1203      and the writer do not agree on a streamed node, the pointer
1204      value for EXPR can be used to track down the differences in
1205      the debugger.  */
1206   gcc_assert ((HOST_WIDEST_INT) (intptr_t) expr == (intptr_t) expr);
1207   output_sleb128 (ob, (HOST_WIDEST_INT) (intptr_t) expr);
1208 #endif
1209
1210   /* The text in strings and identifiers are completely emitted in
1211      the header.  */
1212   if (CODE_CONTAINS_STRUCT (code, TS_STRING))
1213     output_string_cst (ob, ob->main_stream, expr);
1214   else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
1215     output_identifier (ob, ob->main_stream, expr);
1216   else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1217     output_sleb128 (ob, TREE_VEC_LENGTH (expr));
1218   else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1219     output_uleb128 (ob, BINFO_N_BASE_BINFOS (expr));
1220 }
1221
1222
1223 /* Write the code and class of builtin EXPR to output block OB.  IX is
1224    the index into the streamer cache where EXPR is stored.*/
1225
1226 static void
1227 lto_output_builtin_tree (struct output_block *ob, tree expr, int ix)
1228 {
1229   gcc_assert (lto_stream_as_builtin_p (expr));
1230
1231   if (DECL_BUILT_IN_CLASS (expr) == BUILT_IN_MD
1232       && !targetm.builtin_decl)
1233     sorry ("gimple bytecode streams do not support machine specific builtin "
1234            "functions on this target");
1235
1236   output_record_start (ob, LTO_builtin_decl);
1237   output_uleb128 (ob, DECL_BUILT_IN_CLASS (expr));
1238   output_uleb128 (ob, DECL_FUNCTION_CODE (expr));
1239   output_sleb128 (ob, ix);
1240
1241   if (DECL_ASSEMBLER_NAME_SET_P (expr))
1242     {
1243       /* When the assembler name of a builtin gets a user name,
1244          the new name is always prefixed with '*' by
1245          set_builtin_user_assembler_name.  So, to prevent the
1246          reader side from adding a second '*', we omit it here.  */
1247       const char *str = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (expr));
1248       if (strlen (str) > 1 && str[0] == '*')
1249         output_string (ob, ob->main_stream, &str[1]);
1250       else
1251         output_string (ob, ob->main_stream, NULL);
1252     }
1253   else
1254     output_string (ob, ob->main_stream, NULL);
1255 }
1256
1257
1258 /* Write a physical representation of tree node EXPR to output block
1259    OB.  If REF_P is true, the leaves of EXPR are emitted as references
1260    via lto_output_tree_ref.  IX is the index into the streamer cache
1261    where EXPR is stored.  */
1262
1263 static void
1264 lto_write_tree (struct output_block *ob, tree expr, bool ref_p, int ix)
1265 {
1266   struct bitpack_d *bp;
1267
1268   /* Write the header, containing everything needed to materialize
1269      EXPR on the reading side.  */
1270   lto_output_tree_header (ob, expr, ix);
1271
1272   /* Pack all the non-pointer fields in EXPR into a bitpack and write
1273      the resulting bitpack.  */
1274   bp = pack_value_fields (expr);
1275   lto_output_bitpack (ob->main_stream, bp);
1276   bitpack_delete (bp);
1277
1278   /* Write all the pointer fields in EXPR.  */
1279   lto_output_tree_pointers (ob, expr, ref_p);
1280
1281   /* Mark the end of EXPR.  */
1282   output_zero (ob);
1283 }
1284
1285
1286 /* Emit the integer constant CST to output block OB.  If REF_P is true,
1287    CST's type will be emitted as a reference.  */
1288
1289 static void
1290 lto_output_integer_cst (struct output_block *ob, tree cst, bool ref_p)
1291 {
1292   output_record_start (ob, lto_tree_code_to_tag (INTEGER_CST));
1293   lto_output_tree_or_ref (ob, TREE_TYPE (cst), ref_p);
1294   lto_output_1_stream (ob->main_stream, TREE_OVERFLOW_P (cst));
1295   output_uleb128 (ob, TREE_INT_CST_LOW (cst));
1296   output_uleb128 (ob, TREE_INT_CST_HIGH (cst));
1297 }
1298
1299
1300 /* Emit the physical representation of tree node EXPR to output block
1301    OB.  If REF_P is true, the leaves of EXPR are emitted as references
1302    via lto_output_tree_ref.  */
1303
1304 void
1305 lto_output_tree (struct output_block *ob, tree expr, bool ref_p)
1306 {
1307   int ix;
1308   bool existed_p;
1309   unsigned offset;
1310
1311   if (expr == NULL_TREE)
1312     {
1313       output_zero (ob);
1314       return;
1315     }
1316
1317   /* INTEGER_CST nodes are special because they need their original type
1318      to be materialized by the reader (to implement TYPE_CACHED_VALUES).  */
1319   if (TREE_CODE (expr) == INTEGER_CST)
1320     {
1321       lto_output_integer_cst (ob, expr, ref_p);
1322       return;
1323     }
1324
1325   /* Determine the offset in the stream where EXPR will be written.
1326      This is used when emitting pickle references so the reader knows
1327      where to reconstruct the pickled object from.  This allows
1328      circular and forward references within the same stream.  */
1329   offset = ob->main_stream->total_size;
1330
1331   existed_p = lto_streamer_cache_insert (ob->writer_cache, expr, &ix, &offset);
1332   if (existed_p)
1333     {
1334       /* If a node has already been streamed out, make sure that
1335          we don't write it more than once.  Otherwise, the reader
1336          will instantiate two different nodes for the same object.  */
1337       output_record_start (ob, LTO_tree_pickle_reference);
1338       output_sleb128 (ob, ix);
1339       output_uleb128 (ob, lto_tree_code_to_tag (TREE_CODE (expr)));
1340       output_uleb128 (ob, offset);
1341     }
1342   else if (lto_stream_as_builtin_p (expr))
1343     {
1344       /* MD and NORMAL builtins do not need to be written out
1345          completely as they are always instantiated by the
1346          compiler on startup.  The only builtins that need to
1347          be written out are BUILT_IN_FRONTEND.  For all other
1348          builtins, we simply write the class and code.  */
1349       lto_output_builtin_tree (ob, expr, ix);
1350     }
1351   else
1352     {
1353       /* This is the first time we see EXPR, write its fields
1354          to OB.  */
1355       lto_write_tree (ob, expr, ref_p, ix);
1356     }
1357 }
1358
1359
1360 /* Output to OB a list of try/catch handlers starting with FIRST.  */
1361
1362 static void
1363 output_eh_try_list (struct output_block *ob, eh_catch first)
1364 {
1365   eh_catch n;
1366
1367   for (n = first; n; n = n->next_catch)
1368     {
1369       output_record_start (ob, LTO_eh_catch);
1370       lto_output_tree_ref (ob, n->type_list);
1371       lto_output_tree_ref (ob, n->filter_list);
1372       lto_output_tree_ref (ob, n->label);
1373     }
1374
1375   output_zero (ob);
1376 }
1377
1378
1379 /* Output EH region R in function FN to OB.  CURR_RN is the slot index
1380    that is being emitted in FN->EH->REGION_ARRAY.  This is used to
1381    detect EH region sharing.  */
1382
1383 static void
1384 output_eh_region (struct output_block *ob, eh_region r)
1385 {
1386   enum LTO_tags tag;
1387
1388   if (r == NULL)
1389     {
1390       output_zero (ob);
1391       return;
1392     }
1393
1394   if (r->type == ERT_CLEANUP)
1395     tag = LTO_ert_cleanup;
1396   else if (r->type == ERT_TRY)
1397     tag = LTO_ert_try;
1398   else if (r->type == ERT_ALLOWED_EXCEPTIONS)
1399     tag = LTO_ert_allowed_exceptions;
1400   else if (r->type == ERT_MUST_NOT_THROW)
1401     tag = LTO_ert_must_not_throw;
1402   else
1403     gcc_unreachable ();
1404
1405   output_record_start (ob, tag);
1406   output_sleb128 (ob, r->index);
1407
1408   if (r->outer)
1409     output_sleb128 (ob, r->outer->index);
1410   else
1411     output_zero (ob);
1412
1413   if (r->inner)
1414     output_sleb128 (ob, r->inner->index);
1415   else
1416     output_zero (ob);
1417
1418   if (r->next_peer)
1419     output_sleb128 (ob, r->next_peer->index);
1420   else
1421     output_zero (ob);
1422
1423   if (r->type == ERT_TRY)
1424     {
1425       output_eh_try_list (ob, r->u.eh_try.first_catch);
1426     }
1427   else if (r->type == ERT_ALLOWED_EXCEPTIONS)
1428     {
1429       lto_output_tree_ref (ob, r->u.allowed.type_list);
1430       lto_output_tree_ref (ob, r->u.allowed.label);
1431       output_uleb128 (ob, r->u.allowed.filter);
1432     }
1433   else if (r->type == ERT_MUST_NOT_THROW)
1434     {
1435       lto_output_tree_ref (ob, r->u.must_not_throw.failure_decl);
1436       lto_output_location (ob, r->u.must_not_throw.failure_loc);
1437     }
1438
1439   if (r->landing_pads)
1440     output_sleb128 (ob, r->landing_pads->index);
1441   else
1442     output_zero (ob);
1443 }
1444
1445
1446 /* Output landing pad LP to OB.  */
1447
1448 static void
1449 output_eh_lp (struct output_block *ob, eh_landing_pad lp)
1450 {
1451   if (lp == NULL)
1452     {
1453       output_zero (ob);
1454       return;
1455     }
1456
1457   output_record_start (ob, LTO_eh_landing_pad);
1458   output_sleb128 (ob, lp->index);
1459   if (lp->next_lp)
1460     output_sleb128 (ob, lp->next_lp->index);
1461   else
1462     output_zero (ob);
1463
1464   if (lp->region)
1465     output_sleb128 (ob, lp->region->index);
1466   else
1467     output_zero (ob);
1468
1469   lto_output_tree_ref (ob, lp->post_landing_pad);
1470 }
1471
1472
1473 /* Output the existing eh_table to OB.  */
1474
1475 static void
1476 output_eh_regions (struct output_block *ob, struct function *fn)
1477 {
1478   if (fn->eh && fn->eh->region_tree)
1479     {
1480       unsigned i;
1481       eh_region eh;
1482       eh_landing_pad lp;
1483       tree ttype;
1484
1485       output_record_start (ob, LTO_eh_table);
1486
1487       /* Emit the index of the root of the EH region tree.  */
1488       output_sleb128 (ob, fn->eh->region_tree->index);
1489
1490       /* Emit all the EH regions in the region array.  */
1491       output_sleb128 (ob, VEC_length (eh_region, fn->eh->region_array));
1492       for (i = 0; VEC_iterate (eh_region, fn->eh->region_array, i, eh); i++)
1493         output_eh_region (ob, eh);
1494
1495       /* Emit all landing pads.  */
1496       output_sleb128 (ob, VEC_length (eh_landing_pad, fn->eh->lp_array));
1497       for (i = 0; VEC_iterate (eh_landing_pad, fn->eh->lp_array, i, lp); i++)
1498         output_eh_lp (ob, lp);
1499
1500       /* Emit all the runtime type data.  */
1501       output_sleb128 (ob, VEC_length (tree, fn->eh->ttype_data));
1502       for (i = 0; VEC_iterate (tree, fn->eh->ttype_data, i, ttype); i++)
1503         lto_output_tree_ref (ob, ttype);
1504
1505       /* Emit the table of action chains.  */
1506       if (targetm.arm_eabi_unwinder)
1507         {
1508           tree t;
1509           output_sleb128 (ob, VEC_length (tree, fn->eh->ehspec_data.arm_eabi));
1510           for (i = 0;
1511                VEC_iterate (tree, fn->eh->ehspec_data.arm_eabi, i, t);
1512                i++)
1513             lto_output_tree_ref (ob, t);
1514         }
1515       else
1516         {
1517           uchar c;
1518           output_sleb128 (ob, VEC_length (uchar, fn->eh->ehspec_data.other));
1519           for (i = 0; VEC_iterate (uchar, fn->eh->ehspec_data.other, i, c); i++)
1520             lto_output_1_stream (ob->main_stream, c);
1521         }
1522     }
1523
1524   /* The 0 either terminates the record or indicates that there are no
1525      eh_records at all.  */
1526   output_zero (ob);
1527 }
1528
1529
1530 /* Output all of the active ssa names to the ssa_names stream.  */
1531
1532 static void
1533 output_ssa_names (struct output_block *ob, struct function *fn)
1534 {
1535   unsigned int i, len;
1536
1537   len = VEC_length (tree, SSANAMES (fn));
1538   output_uleb128 (ob, len);
1539
1540   for (i = 1; i < len; i++)
1541     {
1542       tree ptr = VEC_index (tree, SSANAMES (fn), i);
1543
1544       if (ptr == NULL_TREE
1545           || SSA_NAME_IN_FREE_LIST (ptr)
1546           || !is_gimple_reg (ptr))
1547         continue;
1548
1549       output_uleb128 (ob, i);
1550       lto_output_1_stream (ob->main_stream, SSA_NAME_IS_DEFAULT_DEF (ptr));
1551       lto_output_tree_ref (ob, SSA_NAME_VAR (ptr));
1552     }
1553
1554   output_zero (ob);
1555 }
1556
1557
1558 /* Output the cfg.  */
1559
1560 static void
1561 output_cfg (struct output_block *ob, struct function *fn)
1562 {
1563   struct lto_output_stream *tmp_stream = ob->main_stream;
1564   basic_block bb;
1565
1566   ob->main_stream = ob->cfg_stream;
1567
1568   output_uleb128 (ob, profile_status_for_function (fn));
1569
1570   /* Output the number of the highest basic block.  */
1571   output_uleb128 (ob, last_basic_block_for_function (fn));
1572
1573   FOR_ALL_BB_FN (bb, fn)
1574     {
1575       edge_iterator ei;
1576       edge e;
1577
1578       output_sleb128 (ob, bb->index);
1579
1580       /* Output the successors and the edge flags.  */
1581       output_uleb128 (ob, EDGE_COUNT (bb->succs));
1582       FOR_EACH_EDGE (e, ei, bb->succs)
1583         {
1584           output_uleb128 (ob, e->dest->index);
1585           output_sleb128 (ob, e->probability);
1586           output_sleb128 (ob, e->count);
1587           output_uleb128 (ob, e->flags);
1588         }
1589     }
1590
1591   output_sleb128 (ob, -1);
1592
1593   bb = ENTRY_BLOCK_PTR;
1594   while (bb->next_bb)
1595     {
1596       output_sleb128 (ob, bb->next_bb->index);
1597       bb = bb->next_bb;
1598     }
1599
1600   output_sleb128 (ob, -1);
1601
1602   ob->main_stream = tmp_stream;
1603 }
1604
1605
1606 /* Output PHI function PHI to the main stream in OB.  */
1607
1608 static void
1609 output_phi (struct output_block *ob, gimple phi)
1610 {
1611   unsigned i, len = gimple_phi_num_args (phi);
1612   
1613   output_record_start (ob, lto_gimple_code_to_tag (GIMPLE_PHI));
1614   output_uleb128 (ob, SSA_NAME_VERSION (PHI_RESULT (phi)));
1615
1616   for (i = 0; i < len; i++)
1617     {
1618       lto_output_tree_ref (ob, gimple_phi_arg_def (phi, i));
1619       output_uleb128 (ob, gimple_phi_arg_edge (phi, i)->src->index);
1620       lto_output_location (ob, gimple_phi_arg_location (phi, i));
1621     }
1622 }
1623
1624
1625 /* Emit statement STMT on the main stream of output block OB.  */
1626
1627 static void
1628 output_gimple_stmt (struct output_block *ob, gimple stmt)
1629 {
1630   unsigned i;
1631   enum gimple_code code;
1632   enum LTO_tags tag;
1633   struct bitpack_d *bp;
1634
1635   /* Emit identifying tag.  */
1636   code = gimple_code (stmt);
1637   tag = lto_gimple_code_to_tag (code);
1638   output_record_start (ob, tag);
1639
1640   /* Emit the tuple header.  */
1641   bp = bitpack_create ();
1642   bp_pack_value (bp, gimple_num_ops (stmt), sizeof (unsigned) * 8);
1643   bp_pack_value (bp, gimple_no_warning_p (stmt), 1);
1644   if (is_gimple_assign (stmt))
1645     bp_pack_value (bp, gimple_assign_nontemporal_move_p (stmt), 1);
1646   bp_pack_value (bp, gimple_has_volatile_ops (stmt), 1);
1647   bp_pack_value (bp, stmt->gsbase.subcode, 16);
1648   lto_output_bitpack (ob->main_stream, bp);
1649   bitpack_delete (bp);
1650
1651   /* Emit location information for the statement.  */
1652   lto_output_location (ob, gimple_location (stmt));
1653
1654   /* Emit the lexical block holding STMT.  */
1655   lto_output_tree (ob, gimple_block (stmt), true);
1656
1657   /* Emit the operands.  */
1658   switch (gimple_code (stmt))
1659     {
1660     case GIMPLE_RESX:
1661       output_sleb128 (ob, gimple_resx_region (stmt));
1662       break;
1663
1664     case GIMPLE_EH_MUST_NOT_THROW:
1665       lto_output_tree_ref (ob, gimple_eh_must_not_throw_fndecl (stmt));
1666       break;
1667
1668     case GIMPLE_EH_DISPATCH:
1669       output_sleb128 (ob, gimple_eh_dispatch_region (stmt));
1670       break;
1671
1672     case GIMPLE_ASM:
1673       lto_output_uleb128_stream (ob->main_stream, gimple_asm_ninputs (stmt));
1674       lto_output_uleb128_stream (ob->main_stream, gimple_asm_noutputs (stmt));
1675       lto_output_uleb128_stream (ob->main_stream, gimple_asm_nclobbers (stmt));
1676       output_string (ob, ob->main_stream, gimple_asm_string (stmt));
1677       /* Fallthru  */
1678
1679     case GIMPLE_ASSIGN:
1680     case GIMPLE_CALL:
1681     case GIMPLE_RETURN:
1682     case GIMPLE_SWITCH:
1683     case GIMPLE_LABEL:
1684     case GIMPLE_COND:
1685     case GIMPLE_GOTO:
1686     case GIMPLE_DEBUG:
1687       for (i = 0; i < gimple_num_ops (stmt); i++)
1688         {
1689           tree op = gimple_op (stmt, i);
1690           lto_output_tree_ref (ob, op);
1691         }
1692       break;
1693
1694     case GIMPLE_NOP:
1695     case GIMPLE_PREDICT:
1696       break;
1697
1698     default:
1699       gcc_unreachable ();
1700     }
1701 }
1702
1703
1704 /* Output a basic block BB to the main stream in OB for this FN.  */
1705
1706 static void
1707 output_bb (struct output_block *ob, basic_block bb, struct function *fn)
1708 {
1709   gimple_stmt_iterator bsi = gsi_start_bb (bb);
1710
1711   output_record_start (ob,
1712                        (!gsi_end_p (bsi)) || phi_nodes (bb)
1713                         ? LTO_bb1
1714                         : LTO_bb0);
1715
1716   output_uleb128 (ob, bb->index);
1717   output_sleb128 (ob, bb->count);
1718   output_sleb128 (ob, bb->loop_depth);
1719   output_sleb128 (ob, bb->frequency);
1720   output_sleb128 (ob, bb->flags);
1721
1722   if (!gsi_end_p (bsi) || phi_nodes (bb))
1723     {
1724       /* Output the statements.  The list of statements is terminated
1725          with a zero.  */
1726       for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
1727         {
1728           int region;
1729           gimple stmt = gsi_stmt (bsi);
1730
1731           output_gimple_stmt (ob, stmt);
1732         
1733           /* Emit the EH region holding STMT.  */
1734           region = lookup_stmt_eh_lp_fn (fn, stmt);
1735           if (region != 0)
1736             {
1737               output_record_start (ob, LTO_eh_region);
1738               output_sleb128 (ob, region);
1739             }
1740           else
1741             output_zero (ob);
1742         }
1743
1744       output_zero (ob);
1745
1746       for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi))
1747         {
1748           gimple phi = gsi_stmt (bsi);
1749
1750           /* Only emit PHIs for gimple registers.  PHI nodes for .MEM
1751              will be filled in on reading when the SSA form is
1752              updated.  */
1753           if (is_gimple_reg (gimple_phi_result (phi)))
1754             output_phi (ob, phi);
1755         }
1756
1757       output_zero (ob);
1758     }
1759 }
1760
1761 /* Create the header in the file using OB.  If the section type is for
1762    a function, set FN to the decl for that function.  */
1763
1764 static void
1765 produce_asm (struct output_block *ob, tree fn)
1766 {
1767   enum lto_section_type section_type = ob->section_type;
1768   struct lto_function_header header;
1769   char *section_name;
1770   struct lto_output_stream *header_stream;
1771
1772   if (section_type == LTO_section_function_body)
1773     {
1774       const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn));
1775       section_name = lto_get_section_name (section_type, name);
1776     }
1777   else
1778     section_name = lto_get_section_name (section_type, NULL);
1779
1780   lto_begin_section (section_name, !flag_wpa);
1781   free (section_name);
1782
1783   /* The entire header is stream computed here.  */
1784   memset (&header, 0, sizeof (struct lto_function_header));
1785   
1786   /* Write the header.  */
1787   header.lto_header.major_version = LTO_major_version;
1788   header.lto_header.minor_version = LTO_minor_version;
1789   header.lto_header.section_type = section_type;
1790   
1791   header.compressed_size = 0;
1792   
1793   if (section_type == LTO_section_function_body)
1794     header.cfg_size = ob->cfg_stream->total_size;
1795   header.main_size = ob->main_stream->total_size;
1796   header.string_size = ob->string_stream->total_size;
1797
1798   header_stream = XCNEW (struct lto_output_stream);
1799   lto_output_data_stream (header_stream, &header, sizeof header);
1800   lto_write_stream (header_stream);
1801   free (header_stream);
1802
1803   /* Put all of the gimple and the string table out the asm file as a
1804      block of text.  */
1805   if (section_type == LTO_section_function_body)
1806     lto_write_stream (ob->cfg_stream);
1807   lto_write_stream (ob->main_stream);
1808   lto_write_stream (ob->string_stream);
1809
1810   lto_end_section ();
1811 }
1812
1813
1814 /* Output the body of function NODE->DECL.  */
1815
1816 static void
1817 output_function (struct cgraph_node *node)
1818 {
1819   struct bitpack_d *bp;
1820   tree function;
1821   struct function *fn;
1822   basic_block bb;
1823   struct output_block *ob;
1824
1825   function = node->decl;
1826   fn = DECL_STRUCT_FUNCTION (function);
1827   ob = create_output_block (LTO_section_function_body);
1828
1829   clear_line_info (ob);
1830   ob->cgraph_node = node;
1831
1832   gcc_assert (current_function_decl == NULL_TREE && cfun == NULL);
1833
1834   /* Set current_function_decl and cfun.  */
1835   current_function_decl = function;
1836   push_cfun (fn);
1837
1838   /* Make string 0 be a NULL string.  */
1839   lto_output_1_stream (ob->string_stream, 0);
1840
1841   output_record_start (ob, LTO_function);
1842
1843   /* Write all the attributes for FN.  */
1844   bp = bitpack_create ();
1845   bp_pack_value (bp, fn->is_thunk, 1);
1846   bp_pack_value (bp, fn->has_local_explicit_reg_vars, 1);
1847   bp_pack_value (bp, fn->after_tree_profile, 1);
1848   bp_pack_value (bp, fn->returns_pcc_struct, 1);
1849   bp_pack_value (bp, fn->returns_struct, 1);
1850   bp_pack_value (bp, fn->always_inline_functions_inlined, 1);
1851   bp_pack_value (bp, fn->after_inlining, 1);
1852   bp_pack_value (bp, fn->dont_save_pending_sizes_p, 1);
1853   bp_pack_value (bp, fn->stdarg, 1);
1854   bp_pack_value (bp, fn->has_nonlocal_label, 1);
1855   bp_pack_value (bp, fn->calls_alloca, 1);
1856   bp_pack_value (bp, fn->calls_setjmp, 1);
1857   bp_pack_value (bp, fn->function_frequency, 2);
1858   bp_pack_value (bp, fn->va_list_fpr_size, 8);
1859   bp_pack_value (bp, fn->va_list_gpr_size, 8);
1860   lto_output_bitpack (ob->main_stream, bp);
1861   bitpack_delete (bp);
1862
1863   /* Output the static chain and non-local goto save area.  */
1864   lto_output_tree_ref (ob, fn->static_chain_decl);
1865   lto_output_tree_ref (ob, fn->nonlocal_goto_save_area);
1866
1867   /* Output all the local variables in the function.  */
1868   lto_output_tree_ref (ob, fn->local_decls);
1869
1870   /* Output all the SSA names used in the function.  */
1871   output_ssa_names (ob, fn);
1872
1873   /* Output any exception handling regions.  */
1874   output_eh_regions (ob, fn);
1875
1876   /* Output DECL_INITIAL for the function, which contains the tree of
1877      lexical scopes.  */
1878   lto_output_tree (ob, DECL_INITIAL (function), true);
1879
1880   /* Output the head of the arguments list.  */
1881   lto_output_tree_ref (ob, DECL_ARGUMENTS (function));
1882
1883   /* We will renumber the statements.  The code that does this uses
1884      the same ordering that we use for serializing them so we can use
1885      the same code on the other end and not have to write out the
1886      statement numbers.  */
1887   renumber_gimple_stmt_uids ();
1888
1889   /* Output the code for the function.  */
1890   FOR_ALL_BB_FN (bb, fn)
1891     output_bb (ob, bb, fn);
1892
1893   /* The terminator for this function.  */
1894   output_zero (ob);
1895
1896   output_cfg (ob, fn);
1897
1898   /* Create a section to hold the pickled output of this function.   */
1899   produce_asm (ob, function);
1900
1901   destroy_output_block (ob);
1902
1903   current_function_decl = NULL;
1904   pop_cfun ();
1905 }
1906
1907
1908 /* Return true if alias pair P belongs to the set of cgraph nodes in
1909    SET.  If P is a an alias for a VAR_DECL, it can always be emitted.
1910    However, for FUNCTION_DECL aliases, we should only output the pair
1911    if it belongs to a function whose cgraph node is in SET.
1912    Otherwise, the LTRANS phase will get into trouble when finalizing
1913    aliases because the alias will refer to a function not defined in
1914    the file processed by LTRANS.  */
1915
1916 static bool
1917 output_alias_pair_p (alias_pair *p, cgraph_node_set set)
1918 {
1919   cgraph_node_set_iterator csi;
1920   struct cgraph_node *target_node;
1921
1922   /* Always emit VAR_DECLs.  FIXME lto, we should probably only emit
1923      those VAR_DECLs that are instantiated in this file partition, but
1924      we have no easy way of knowing this based on SET.  */
1925   if (TREE_CODE (p->decl) == VAR_DECL)
1926     return true;
1927
1928   /* Check if the assembler name for P->TARGET has its cgraph node in SET.  */
1929   gcc_assert (TREE_CODE (p->decl) == FUNCTION_DECL);
1930   target_node = cgraph_node_for_asm (p->target);
1931   csi = cgraph_node_set_find (set, target_node);
1932   return (!csi_end_p (csi));
1933 }
1934
1935
1936 /* Output any unreferenced global symbol defined in SET, alias pairs
1937    and labels.  */
1938
1939 static void
1940 output_unreferenced_globals (cgraph_node_set set)
1941 {
1942   struct output_block *ob;
1943   alias_pair *p;
1944   unsigned i;
1945   struct varpool_node *vnode;
1946
1947   ob = create_output_block (LTO_section_static_initializer);
1948   ob->cgraph_node = NULL;
1949
1950   clear_line_info (ob);
1951
1952   /* Make string 0 be a NULL string.  */
1953   lto_output_1_stream (ob->string_stream, 0);
1954
1955   /* Emit references for all the global symbols.  If a global symbol
1956      was never referenced in any of the functions of this file, it
1957      would not be emitted otherwise.  This will result in unreferenced
1958      symbols at link time if a file defines a global symbol but
1959      never references it.  */
1960   FOR_EACH_STATIC_VARIABLE (vnode)
1961     {
1962       tree var = vnode->decl;
1963
1964       if (TREE_CODE (var) == VAR_DECL && TREE_PUBLIC (var))
1965         lto_output_tree_ref (ob, var);
1966     }
1967
1968   output_zero (ob);
1969
1970   /* Emit the alias pairs for the nodes in SET.  */
1971   for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++)
1972     {
1973       if (output_alias_pair_p (p, set))
1974         {
1975           lto_output_tree_ref (ob, p->decl);
1976           lto_output_tree_ref (ob, p->target);
1977         }
1978     }
1979
1980   output_zero (ob);
1981
1982   produce_asm (ob, NULL);
1983   destroy_output_block (ob);
1984 }
1985
1986
1987 /* Copy the function body of NODE without deserializing. */
1988
1989 static void
1990 copy_function (struct cgraph_node *node)
1991 {
1992   tree function = node->decl;
1993   struct lto_file_decl_data *file_data = node->local.lto_file_data;
1994   struct lto_output_stream *output_stream = XCNEW (struct lto_output_stream);
1995   const char *data;
1996   size_t len;
1997   const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function));
1998   char *section_name =
1999     lto_get_section_name (LTO_section_function_body, name);
2000   size_t i, j;
2001   struct lto_in_decl_state *in_state;
2002   struct lto_out_decl_state *out_state = lto_get_out_decl_state ();
2003
2004   lto_begin_section (section_name, !flag_wpa);
2005   free (section_name);
2006
2007   /* We may have renamed the declaration, e.g., a static function.  */
2008   name = lto_get_decl_name_mapping (file_data, name);
2009
2010   data = lto_get_section_data (file_data, LTO_section_function_body,
2011                                name, &len);
2012   gcc_assert (data);
2013
2014   /* Do a bit copy of the function body.  */
2015   lto_output_data_stream (output_stream, data, len);
2016   lto_write_stream (output_stream);
2017
2018   /* Copy decls. */
2019   in_state =
2020     lto_get_function_in_decl_state (node->local.lto_file_data, function);
2021   gcc_assert (in_state);
2022
2023   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
2024     {
2025       size_t n = in_state->streams[i].size;
2026       tree *trees = in_state->streams[i].trees;
2027       struct lto_tree_ref_encoder *encoder = &(out_state->streams[i]);
2028
2029       /* The out state must have the same indices and the in state.
2030          So just copy the vector.  All the encoders in the in state
2031          must be empty where we reach here. */
2032       gcc_assert (lto_tree_ref_encoder_size (encoder) == 0);
2033       for (j = 0; j < n; j++)
2034         VEC_safe_push (tree, heap, encoder->trees, trees[j]);
2035       encoder->next_index = n;
2036     }
2037   
2038   lto_free_section_data (file_data, LTO_section_function_body, name,
2039                          data, len);
2040   free (output_stream);
2041   lto_end_section ();
2042 }
2043
2044
2045 /* Initialize the LTO writer.  */
2046
2047 static void
2048 lto_writer_init (void)
2049 {
2050   lto_streamer_init ();
2051 }
2052
2053
2054 /* Main entry point from the pass manager.  */
2055
2056 static void
2057 lto_output (cgraph_node_set set)
2058 {
2059   struct cgraph_node *node;
2060   struct lto_out_decl_state *decl_state;
2061   cgraph_node_set_iterator csi;
2062   bitmap output = lto_bitmap_alloc ();
2063
2064   lto_writer_init ();
2065
2066   /* Process only the functions with bodies.  */
2067   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2068     {
2069       node = csi_node (csi);
2070       if (node->analyzed && !bitmap_bit_p (output, DECL_UID (node->decl)))
2071         {
2072           bitmap_set_bit (output, DECL_UID (node->decl));
2073           decl_state = lto_new_out_decl_state ();
2074           lto_push_out_decl_state (decl_state);
2075           if (!flag_wpa)
2076             output_function (node);
2077           else
2078             copy_function (node);
2079           gcc_assert (lto_get_out_decl_state () == decl_state);
2080           lto_pop_out_decl_state ();
2081           lto_record_function_out_decl_state (node->decl, decl_state);
2082         }
2083     }
2084
2085   /* Emit the callgraph after emitting function bodies.  This needs to
2086      be done now to make sure that all the statements in every function
2087      have been renumbered so that edges can be associated with call
2088      statements using the statement UIDs.  */
2089   output_cgraph (set);
2090
2091   lto_bitmap_free (output);
2092 }
2093
2094 struct ipa_opt_pass_d pass_ipa_lto_gimple_out =
2095 {
2096  {
2097   IPA_PASS,
2098   "lto_gimple_out",                     /* name */
2099   gate_lto_out,                         /* gate */
2100   NULL,                                 /* execute */
2101   NULL,                                 /* sub */
2102   NULL,                                 /* next */
2103   0,                                    /* static_pass_number */
2104   TV_IPA_LTO_GIMPLE_IO,                 /* tv_id */
2105   0,                                    /* properties_required */
2106   0,                                    /* properties_provided */
2107   0,                                    /* properties_destroyed */
2108   0,                                    /* todo_flags_start */
2109   TODO_dump_func                        /* todo_flags_finish */
2110  },
2111  NULL,                                  /* generate_summary */
2112  lto_output,                            /* write_summary */
2113  NULL,                                  /* read_summary */
2114  NULL,                                  /* function_read_summary */
2115  0,                                     /* TODOs */
2116  NULL,                                  /* function_transform */
2117  NULL                                   /* variable_transform */
2118 };
2119
2120
2121 /* Write each node in encoded by ENCODER to OB, as well as those reachable 
2122    from it and required for correct representation of its semantics.
2123    Each node in ENCODER must be a global declaration or a type.  A node
2124    is written only once, even if it appears multiple times in the
2125    vector.  Certain transitively-reachable nodes, such as those
2126    representing expressions, may be duplicated, but such nodes
2127    must not appear in ENCODER itself.  */
2128
2129 static void
2130 write_global_stream (struct output_block *ob,
2131                      struct lto_tree_ref_encoder *encoder)
2132 {
2133   tree t;
2134   size_t index;
2135   const size_t size = lto_tree_ref_encoder_size (encoder);
2136
2137   for (index = 0; index < size; index++)
2138     {
2139       t = lto_tree_ref_encoder_get_tree (encoder, index);
2140       if (!lto_streamer_cache_lookup (ob->writer_cache, t, NULL))
2141         {
2142           if (flag_wpa)
2143             {
2144               /* In WPA we should not emit multiple definitions of the
2145                  same symbol to all the files in the link set.  If
2146                  T had already been emitted as the pervailing definition
2147                  in one file, emit it as an external reference in the
2148                  others.  */
2149               /* FIXME lto.  We should check if T belongs to the
2150                  file we are writing to.  */
2151               if (TREE_CODE (t) == VAR_DECL
2152                   && TREE_PUBLIC (t)
2153                   && !DECL_EXTERNAL (t))
2154                 {
2155                   /* FIXME lto.  Make DECLS_ALREADY_EMITTED an argument
2156                      to this function so it can be freed up afterwards.
2157                      Alternately, assign global symbols to cgraph
2158                      node sets.  */
2159                   static struct pointer_set_t *decls_already_emitted = NULL;
2160
2161                   if (decls_already_emitted == NULL)
2162                     decls_already_emitted = pointer_set_create ();
2163
2164                   if (pointer_set_insert (decls_already_emitted, t))
2165                     make_decl_one_only (t, DECL_ASSEMBLER_NAME (t));
2166                 }
2167             }
2168
2169           lto_output_tree (ob, t, false);
2170         }
2171     }
2172 }
2173
2174
2175 /* Write a sequence of indices into the globals vector corresponding
2176    to the trees in ENCODER.  These are used by the reader to map the
2177    indices used to refer to global entities within function bodies to
2178    their referents.  */
2179
2180 static void
2181 write_global_references (struct output_block *ob,
2182                          struct lto_output_stream *ref_stream,
2183                          struct lto_tree_ref_encoder *encoder)
2184 {
2185   tree t;
2186   int32_t index;
2187   const int32_t size = lto_tree_ref_encoder_size (encoder);
2188
2189   /* Write size as 32-bit unsigned. */
2190   lto_output_data_stream (ref_stream, &size, sizeof (int32_t));
2191
2192   for (index = 0; index < size; index++)
2193     {
2194       int32_t slot_num;
2195
2196       t = lto_tree_ref_encoder_get_tree (encoder, index);
2197       lto_streamer_cache_lookup (ob->writer_cache, t, &slot_num);
2198       gcc_assert (slot_num >= 0);
2199       lto_output_data_stream (ref_stream, &slot_num, sizeof slot_num);
2200     }
2201 }
2202
2203
2204 /* Write all the streams in an lto_out_decl_state STATE using
2205    output block OB and output stream OUT_STREAM.  */
2206
2207 static void
2208 lto_output_decl_state_streams (struct output_block *ob,
2209                                struct lto_out_decl_state *state)
2210 {
2211   int i;
2212
2213   for (i = 0;  i < LTO_N_DECL_STREAMS; i++)
2214     write_global_stream (ob, &state->streams[i]);
2215 }
2216
2217
2218 /* Write all the references in an lto_out_decl_state STATE using
2219    output block OB and output stream OUT_STREAM.  */
2220
2221 static void
2222 lto_output_decl_state_refs (struct output_block *ob,
2223                             struct lto_output_stream *out_stream,
2224                             struct lto_out_decl_state *state)
2225 {
2226   unsigned i;
2227   int32_t ref;
2228   tree decl;
2229   
2230   /* Write reference to FUNCTION_DECL.  If there is not function,
2231      write reference to void_type_node. */
2232   decl = (state->fn_decl) ? state->fn_decl : void_type_node;
2233   lto_streamer_cache_lookup (ob->writer_cache, decl, &ref);
2234   gcc_assert (ref >= 0);
2235   lto_output_data_stream (out_stream, &ref, sizeof (int32_t));
2236
2237   for (i = 0;  i < LTO_N_DECL_STREAMS; i++)
2238     write_global_references (ob, out_stream, &state->streams[i]);
2239 }
2240
2241
2242 /* Return the written size of STATE. */
2243
2244 static size_t
2245 lto_out_decl_state_written_size (struct lto_out_decl_state *state)
2246 {
2247   int i;
2248   size_t size;
2249
2250   size = sizeof (int32_t);      /* fn_ref. */
2251   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
2252     {
2253       size += sizeof (int32_t); /* vector size. */
2254       size += (lto_tree_ref_encoder_size (&state->streams[i])
2255                * sizeof (int32_t));
2256     }
2257   return size;
2258 }
2259
2260
2261 /* Helper function of write_symbols_of_kind.  CACHE is the streamer
2262    cache with all the pickled nodes.  STREAM is the stream where to
2263    write the table.  V is a vector with the DECLs that should be on
2264    the table.  SEEN is a bitmap of symbols written so far.  */
2265
2266 static void
2267 write_symbol_vec (struct lto_streamer_cache_d *cache,
2268                   struct lto_output_stream *stream,
2269                   VEC(tree,heap) *v, bitmap seen)
2270 {
2271   tree t;
2272   int index;
2273
2274   for (index = 0; VEC_iterate(tree, v, index, t); index++)
2275     {
2276       const char *name;
2277       enum gcc_plugin_symbol_kind kind;
2278       enum gcc_plugin_symbol_visibility visibility;
2279       int slot_num;
2280       uint64_t size;
2281       const char *comdat;
2282
2283       /* None of the following kinds of symbols are needed in the
2284          symbol table.  */
2285       if (!TREE_PUBLIC (t)
2286           || is_builtin_fn (t)
2287           || DECL_ABSTRACT (t)
2288           || TREE_CODE (t) == RESULT_DECL)
2289         continue;
2290
2291       gcc_assert (TREE_CODE (t) == VAR_DECL
2292                   || TREE_CODE (t) == FUNCTION_DECL);
2293
2294       name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t));
2295
2296       /* FIXME lto: this is from assemble_name_raw in varasm.c. For some
2297          architectures we might have to do the same name manipulations that
2298          ASM_OUTPUT_LABELREF does. */
2299       if (name[0] == '*')
2300         name = &name[1];
2301
2302       lto_streamer_cache_lookup (cache, t, &slot_num);
2303       gcc_assert (slot_num >= 0);
2304
2305       /* Avoid duplicate symbols. */
2306       if (bitmap_bit_p (seen, slot_num))
2307         continue;
2308       else
2309         bitmap_set_bit (seen, slot_num);
2310
2311       if (DECL_EXTERNAL (t))
2312         {
2313           if (DECL_WEAK (t))
2314             kind = GCCPK_WEAKUNDEF;
2315           else
2316             kind = GCCPK_UNDEF;
2317         }
2318       else
2319         {
2320           if (DECL_WEAK (t))
2321             kind = GCCPK_WEAKDEF;
2322           else if (DECL_COMMON (t))
2323             kind = GCCPK_COMMON;
2324           else
2325             kind = GCCPK_DEF;
2326         }
2327
2328       switch (DECL_VISIBILITY(t))
2329         {
2330         case VISIBILITY_DEFAULT:
2331           visibility = GCCPV_DEFAULT;
2332           break;
2333         case VISIBILITY_PROTECTED:
2334           visibility = GCCPV_PROTECTED;
2335           break;
2336         case VISIBILITY_HIDDEN:
2337           visibility = GCCPV_HIDDEN;
2338           break;
2339         case VISIBILITY_INTERNAL:
2340           visibility = GCCPV_INTERNAL;
2341           break;
2342         }
2343
2344       if (kind == GCCPK_COMMON && DECL_SIZE (t))
2345         size = (((uint64_t) TREE_INT_CST_HIGH (DECL_SIZE (t))) << 32)
2346           | TREE_INT_CST_LOW (DECL_SIZE (t));
2347       else
2348         size = 0;
2349
2350       if (DECL_ONE_ONLY (t))
2351         comdat = IDENTIFIER_POINTER (DECL_COMDAT_GROUP (t));
2352       else
2353         comdat = "";
2354
2355       lto_output_data_stream (stream, name, strlen (name) + 1);
2356       lto_output_data_stream (stream, comdat, strlen (comdat) + 1);
2357       lto_output_data_stream (stream, &kind, 1);
2358       lto_output_data_stream (stream, &visibility, 1);
2359       lto_output_data_stream (stream, &size, 8);
2360       lto_output_data_stream (stream, &slot_num, 4);
2361     }
2362 }
2363
2364
2365 /* Write IL symbols of KIND.  CACHE is the streamer cache with all the
2366    pickled nodes.  SEEN is a bitmap of symbols written so far.  */
2367
2368 static void
2369 write_symbols_of_kind (lto_decl_stream_e_t kind,
2370                        struct lto_streamer_cache_d *cache, bitmap seen)
2371 {
2372   struct lto_out_decl_state *out_state;
2373   struct lto_output_stream stream;
2374   unsigned num_fns =
2375     VEC_length (lto_out_decl_state_ptr, lto_function_decl_states);
2376   unsigned idx;
2377
2378   memset (&stream, 0, sizeof (stream));
2379   out_state = lto_get_out_decl_state ();
2380   write_symbol_vec (cache, &stream, out_state->streams[kind].trees, seen);
2381
2382   for (idx = 0; idx < num_fns; idx++)
2383     {
2384       out_state =
2385         VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2386       write_symbol_vec (cache, &stream, out_state->streams[kind].trees, seen);
2387     }
2388
2389   lto_write_stream (&stream);
2390 }
2391
2392
2393 /* Write an IL symbol table.  CACHE is the streamer cache with all the
2394    pickled nodes.  */
2395
2396 static void
2397 produce_symtab (struct lto_streamer_cache_d *cache)
2398 {
2399   char *section_name = lto_get_section_name (LTO_section_symtab, NULL);
2400   bitmap seen;
2401
2402   lto_begin_section (section_name, false);
2403   free (section_name);
2404
2405   seen = lto_bitmap_alloc ();
2406   write_symbols_of_kind (LTO_DECL_STREAM_FN_DECL, cache, seen);
2407   write_symbols_of_kind (LTO_DECL_STREAM_VAR_DECL, cache, seen);
2408   lto_bitmap_free (seen);
2409
2410   lto_end_section ();
2411 }
2412
2413
2414 /* This pass is run after all of the functions are serialized and all
2415    of the IPA passes have written their serialized forms.  This pass
2416    causes the vector of all of the global decls and types used from
2417    this file to be written in to a section that can then be read in to
2418    recover these on other side.  */
2419
2420 static void
2421 produce_asm_for_decls (cgraph_node_set set)
2422 {
2423   struct lto_out_decl_state *out_state;
2424   struct lto_out_decl_state *fn_out_state;
2425   struct lto_decl_header header;
2426   char *section_name;
2427   struct output_block *ob;
2428   struct lto_output_stream *header_stream, *decl_state_stream;
2429   unsigned idx, num_fns;
2430   size_t decl_state_size;
2431   int32_t num_decl_states;
2432
2433   ob = create_output_block (LTO_section_decls);
2434   ob->global = true;
2435
2436   /* Write out unreferenced globals, alias pairs and labels.  We defer
2437      doing this until now so that we can write out only what is
2438      needed.  */
2439   output_unreferenced_globals (set);
2440
2441   memset (&header, 0, sizeof (struct lto_decl_header)); 
2442
2443   section_name = lto_get_section_name (LTO_section_decls, NULL);
2444   lto_begin_section (section_name, !flag_wpa);
2445   free (section_name);
2446
2447   /* Make string 0 be a NULL string.  */
2448   lto_output_1_stream (ob->string_stream, 0);
2449
2450   /* Write the global symbols.  */
2451   out_state = lto_get_out_decl_state ();
2452   num_fns = VEC_length (lto_out_decl_state_ptr, lto_function_decl_states);
2453   lto_output_decl_state_streams (ob, out_state);
2454   for (idx = 0; idx < num_fns; idx++)
2455     {
2456       fn_out_state =
2457         VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2458       lto_output_decl_state_streams (ob, fn_out_state);
2459     }
2460
2461   header.lto_header.major_version = LTO_major_version;
2462   header.lto_header.minor_version = LTO_minor_version;
2463   header.lto_header.section_type = LTO_section_decls;
2464
2465   /* Currently not used.  This field would allow us to preallocate
2466      the globals vector, so that it need not be resized as it is extended.  */
2467   header.num_nodes = -1;
2468
2469   /* Compute the total size of all decl out states. */
2470   decl_state_size = sizeof (int32_t);
2471   decl_state_size += lto_out_decl_state_written_size (out_state);
2472   for (idx = 0; idx < num_fns; idx++)
2473     {
2474       fn_out_state =
2475         VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2476       decl_state_size += lto_out_decl_state_written_size (fn_out_state);
2477     }
2478   header.decl_state_size = decl_state_size;
2479
2480   header.main_size = ob->main_stream->total_size;
2481   header.string_size = ob->string_stream->total_size;
2482
2483   header_stream = XCNEW (struct lto_output_stream);
2484   lto_output_data_stream (header_stream, &header, sizeof header);
2485   lto_write_stream (header_stream);
2486   free (header_stream);
2487  
2488   /* Write the main out-decl state, followed by out-decl states of
2489      functions. */
2490   decl_state_stream = ((struct lto_output_stream *)
2491                        xcalloc (1, sizeof (struct lto_output_stream)));
2492   num_decl_states = num_fns + 1;
2493   lto_output_data_stream (decl_state_stream, &num_decl_states,
2494                           sizeof (num_decl_states));
2495   lto_output_decl_state_refs (ob, decl_state_stream, out_state);
2496   for (idx = 0; idx < num_fns; idx++)
2497     {
2498       fn_out_state =
2499         VEC_index (lto_out_decl_state_ptr, lto_function_decl_states, idx);
2500       lto_output_decl_state_refs (ob, decl_state_stream, fn_out_state);
2501     }
2502   lto_write_stream (decl_state_stream);
2503   free(decl_state_stream); 
2504
2505   lto_write_stream (ob->main_stream);
2506   lto_write_stream (ob->string_stream);
2507
2508   lto_end_section ();
2509
2510   /* Write the symbol table. */
2511   produce_symtab (ob->writer_cache);
2512
2513   /* Write command line opts.  */
2514   lto_write_options ();
2515
2516   /* Deallocate memory and clean up.  */
2517   lto_cgraph_encoder_delete (ob->decl_state->cgraph_node_encoder);
2518   VEC_free (lto_out_decl_state_ptr, heap, lto_function_decl_states);
2519   lto_function_decl_states = NULL;
2520   destroy_output_block (ob);
2521 }
2522
2523
2524 struct ipa_opt_pass_d pass_ipa_lto_finish_out =
2525 {
2526  {
2527   IPA_PASS,
2528   "lto_decls_out",                      /* name */
2529   gate_lto_out,                         /* gate */
2530   NULL,                                 /* execute */
2531   NULL,                                 /* sub */
2532   NULL,                                 /* next */
2533   0,                                    /* static_pass_number */
2534   TV_IPA_LTO_DECL_IO,                   /* tv_id */
2535   0,                                    /* properties_required */
2536   0,                                    /* properties_provided */
2537   0,                                    /* properties_destroyed */
2538   0,                                    /* todo_flags_start */
2539   0                                     /* todo_flags_finish */
2540  },
2541  NULL,                                  /* generate_summary */
2542  produce_asm_for_decls,                 /* write_summary */
2543  NULL,                                  /* read_summary */
2544  NULL,                                  /* function_read_summary */
2545  0,                                     /* TODOs */
2546  NULL,                                  /* function_transform */
2547  NULL                                   /* variable_transform */
2548 };