OSDN Git Service

2009-10-09 Richard Guenther <rguenther@suse.de>
[pf3gnuchains/gcc-fork.git] / gcc / lto-streamer-in.c
1 /* Read the GIMPLE representation from 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 "libfuncs.h"
43 #include "except.h"
44 #include "debug.h"
45 #include "vec.h"
46 #include "timevar.h"
47 #include "output.h"
48 #include "ipa-utils.h"
49 #include "lto-streamer.h"
50
51 /* Data structure used to hash file names in the source_location field.  */
52 struct string_slot
53 {
54   const char *s;
55   unsigned int slot_num;
56 };
57
58 /* The table to hold the file names.  */
59 static htab_t file_name_hash_table;
60
61
62 /* Check that tag ACTUAL has one of the given values.  NUM_TAGS is the
63    number of valid tag values to check.  */
64
65 static void
66 lto_tag_check_set (enum LTO_tags actual, int ntags, ...)
67 {
68   va_list ap;
69   int i;
70
71   va_start (ap, ntags);
72   for (i = 0; i < ntags; i++)
73     if ((unsigned) actual == va_arg (ap, unsigned))
74       {
75         va_end (ap);
76         return;
77       }
78
79   va_end (ap);
80   internal_error ("bytecode stream: unexpected tag %s", lto_tag_name (actual));
81 }
82
83
84 /* Check that tag ACTUAL is in the range [TAG1, TAG2].  */
85
86 static void
87 lto_tag_check_range (enum LTO_tags actual, enum LTO_tags tag1,
88                      enum LTO_tags tag2)
89 {
90   if (actual < tag1 || actual > tag2)
91     internal_error ("bytecode stream: tag %s is not in the expected range "
92                     "[%s, %s]",
93                     lto_tag_name (actual),
94                     lto_tag_name (tag1),
95                     lto_tag_name (tag2));
96 }
97
98
99 /* Check that tag ACTUAL == EXPECTED.  */
100
101 static void
102 lto_tag_check (enum LTO_tags actual, enum LTO_tags expected)
103 {
104   if (actual != expected)
105     internal_error ("bytecode stream: expected tag %s instead of %s",
106                     lto_tag_name (expected), lto_tag_name (actual));
107 }
108
109
110 /* Return a hash code for P.  */
111
112 static hashval_t
113 hash_string_slot_node (const void *p)
114 {
115   const struct string_slot *ds = (const struct string_slot *) p;
116   return (hashval_t) htab_hash_string (ds->s);
117 }
118
119
120 /* Returns nonzero if P1 and P2 are equal.  */
121
122 static int
123 eq_string_slot_node (const void *p1, const void *p2)
124 {
125   const struct string_slot *ds1 = (const struct string_slot *) p1;
126   const struct string_slot *ds2 = (const struct string_slot *) p2;
127   return strcmp (ds1->s, ds2->s) == 0;
128 }
129
130
131 /* Read a string from the string table in DATA_IN using input block
132    IB.  Write the length to RLEN.  */
133
134 static const char *
135 input_string_internal (struct data_in *data_in, struct lto_input_block *ib,
136                        unsigned int *rlen)
137 {
138   struct lto_input_block str_tab;
139   unsigned int len;
140   unsigned int loc;
141   const char *result;
142   
143   loc = lto_input_uleb128 (ib);
144   LTO_INIT_INPUT_BLOCK (str_tab, data_in->strings, loc, data_in->strings_len);
145   len = lto_input_uleb128 (&str_tab);
146   *rlen = len;
147
148   if (str_tab.p + len > data_in->strings_len)
149     internal_error ("bytecode stream: string too long for the string table");
150   
151   result = (const char *)(data_in->strings + str_tab.p);
152
153   return result;
154 }
155
156
157 /* Read a STRING_CST from the string table in DATA_IN using input
158    block IB.  */
159
160 static tree
161 input_string_cst (struct data_in *data_in, struct lto_input_block *ib)
162 {
163   unsigned int len;
164   const char * ptr;
165   unsigned int is_null;
166
167   is_null = lto_input_uleb128 (ib);
168   if (is_null)
169     return NULL;
170
171   ptr = input_string_internal (data_in, ib, &len);
172   return build_string (len, ptr);
173 }
174
175
176 /* Read an IDENTIFIER from the string table in DATA_IN using input
177    block IB.  */
178
179 static tree
180 input_identifier (struct data_in *data_in, struct lto_input_block *ib)
181 {
182   unsigned int len;
183   const char *ptr;
184   unsigned int is_null;
185
186   is_null = lto_input_uleb128 (ib);
187   if (is_null)
188     return NULL;
189
190   ptr = input_string_internal (data_in, ib, &len);
191   return get_identifier_with_length (ptr, len);
192 }
193
194 /* Read a NULL terminated string from the string table in DATA_IN.  */
195
196 static const char *
197 input_string (struct data_in *data_in, struct lto_input_block *ib)
198 {
199   unsigned int len;
200   const char *ptr;
201   unsigned int is_null;
202
203   is_null = lto_input_uleb128 (ib);
204   if (is_null)
205     return NULL;
206
207   ptr = input_string_internal (data_in, ib, &len);
208   if (ptr[len - 1] != '\0')
209     internal_error ("bytecode stream: found non-null terminated string");
210
211   return ptr;
212 }
213
214
215 /* Return the next tag in the input block IB.  */
216
217 static enum LTO_tags
218 input_record_start (struct lto_input_block *ib)
219 {
220   enum LTO_tags tag = (enum LTO_tags) lto_input_uleb128 (ib);
221   return tag;
222
223
224
225 /* Lookup STRING in file_name_hash_table.  If found, return the existing
226    string, otherwise insert STRING as the canonical version.  */
227
228 static const char *
229 canon_file_name (const char *string)
230 {
231   void **slot;
232   struct string_slot s_slot;
233   s_slot.s = string;
234
235   slot = htab_find_slot (file_name_hash_table, &s_slot, INSERT);
236   if (*slot == NULL)
237     {
238       size_t len;
239       char *saved_string;
240       struct string_slot *new_slot;
241
242       len = strlen (string);
243       saved_string = (char *) xmalloc (len + 1);
244       new_slot = XCNEW (struct string_slot);
245       strcpy (saved_string, string);
246       new_slot->s = saved_string;
247       *slot = new_slot;
248       return saved_string;
249     }
250   else
251     {
252       struct string_slot *old_slot = (struct string_slot *) *slot;
253       return old_slot->s;
254     }
255 }
256
257
258 /* Clear the line info stored in DATA_IN.  */
259
260 static void
261 clear_line_info (struct data_in *data_in)
262 {
263   if (data_in->current_file)
264     linemap_add (line_table, LC_LEAVE, false, NULL, 0);
265   data_in->current_file = NULL;
266   data_in->current_line = 0;
267   data_in->current_col = 0;
268 }
269
270
271 /* Read a location from input block IB.  */
272
273 static location_t
274 lto_input_location (struct lto_input_block *ib, struct data_in *data_in)
275 {
276   expanded_location xloc;
277   location_t loc;
278
279   xloc.file = input_string (data_in, ib);
280   if (xloc.file == NULL)
281     return UNKNOWN_LOCATION;
282
283   xloc.line = lto_input_sleb128 (ib);
284   xloc.column = lto_input_sleb128 (ib);
285
286   if (data_in->current_file)
287     linemap_add (line_table, LC_LEAVE, false, NULL, 0);
288
289   data_in->current_file = canon_file_name (xloc.file);
290   data_in->current_line = xloc.line;
291   data_in->current_col = xloc.column;
292
293   linemap_add (line_table, LC_ENTER, false, data_in->current_file, xloc.line);
294   LINEMAP_POSITION_FOR_COLUMN (loc, line_table, xloc.column);
295
296   return loc;
297 }
298
299
300 /* Read a reference to a tree node from DATA_IN using input block IB.
301    TAG is the expected node that should be found in IB, if TAG belongs
302    to one of the indexable trees, expect to read a reference index to
303    be looked up in one of the symbol tables, otherwise read the pysical
304    representation of the tree using lto_input_tree.  FN is the
305    function scope for the read tree.  */
306
307 static tree
308 lto_input_tree_ref (struct lto_input_block *ib, struct data_in *data_in, 
309                     struct function *fn, enum LTO_tags tag)
310 {
311   unsigned HOST_WIDE_INT ix_u;
312   tree result = NULL_TREE;
313
314   lto_tag_check_range (tag, LTO_field_decl_ref, LTO_global_decl_ref);
315
316   switch (tag)
317     {
318     case LTO_type_ref:
319       ix_u = lto_input_uleb128 (ib);
320       result = lto_file_decl_data_get_type (data_in->file_data, ix_u);
321       break;
322
323     case LTO_ssa_name_ref:
324       ix_u = lto_input_uleb128 (ib);
325       result = VEC_index (tree, SSANAMES (fn), ix_u);
326       break;
327
328     case LTO_field_decl_ref:
329       ix_u = lto_input_uleb128 (ib);
330       result = lto_file_decl_data_get_field_decl (data_in->file_data, ix_u);
331       break;
332
333     case LTO_function_decl_ref:
334       ix_u = lto_input_uleb128 (ib);
335       result = lto_file_decl_data_get_fn_decl (data_in->file_data, ix_u);
336       break;
337
338     case LTO_type_decl_ref:
339       ix_u = lto_input_uleb128 (ib);
340       result = lto_file_decl_data_get_type_decl (data_in->file_data, ix_u);
341       break;
342
343     case LTO_namespace_decl_ref:
344       ix_u = lto_input_uleb128 (ib);
345       result = lto_file_decl_data_get_namespace_decl (data_in->file_data, ix_u);
346       break;
347
348     case LTO_global_decl_ref:
349     case LTO_result_decl_ref:
350     case LTO_const_decl_ref:
351     case LTO_imported_decl_ref:
352     case LTO_label_decl_ref:
353       ix_u = lto_input_uleb128 (ib);
354       result = lto_file_decl_data_get_var_decl (data_in->file_data, ix_u);
355       if (tag == LTO_global_decl_ref)
356         varpool_mark_needed_node (varpool_node (result));
357       break;
358
359     default:
360       gcc_unreachable ();
361     }
362
363   gcc_assert (result);
364
365   return result;
366 }
367
368
369 /* Read and return a double-linked list of catch handlers from input
370    block IB, using descriptors in DATA_IN.  */
371
372 static struct eh_catch_d *
373 lto_input_eh_catch_list (struct lto_input_block *ib, struct data_in *data_in,
374                          eh_catch *last_p)
375 {
376   eh_catch first;
377   enum LTO_tags tag;
378
379   *last_p = first = NULL;
380   tag = input_record_start (ib);
381   while (tag)
382     {
383       tree list;
384       eh_catch n;
385
386       lto_tag_check_range (tag, LTO_eh_catch, LTO_eh_catch);
387
388       /* Read the catch node.  */
389       n = GGC_CNEW (struct eh_catch_d);
390       n->type_list = lto_input_tree (ib, data_in);
391       n->filter_list = lto_input_tree (ib, data_in);
392       n->label = lto_input_tree (ib, data_in);
393
394       /* Register all the types in N->FILTER_LIST.  */
395       for (list = n->filter_list; list; list = TREE_CHAIN (list))
396         add_type_for_runtime (TREE_VALUE (list));
397
398       /* Chain N to the end of the list.  */
399       if (*last_p)
400         (*last_p)->next_catch = n;
401       n->prev_catch = *last_p;
402       *last_p = n;
403
404       /* Set the head of the list the first time through the loop.  */
405       if (first == NULL)
406         first = n;
407
408       tag = input_record_start (ib);
409     }
410
411   return first;
412 }
413
414
415 /* Read and return EH region IX from input block IB, using descriptors
416    in DATA_IN.  */
417
418 static eh_region
419 input_eh_region (struct lto_input_block *ib, struct data_in *data_in, int ix)
420 {
421   enum LTO_tags tag;
422   eh_region r;
423
424   /* Read the region header.  */
425   tag = input_record_start (ib);
426   if (tag == LTO_null)
427     return NULL;
428
429   r = GGC_CNEW (struct eh_region_d);
430   r->index = lto_input_sleb128 (ib);
431
432   gcc_assert (r->index == ix);
433
434   /* Read all the region pointers as region numbers.  We'll fix up
435      the pointers once the whole array has been read.  */
436   r->outer = (eh_region) (intptr_t) lto_input_sleb128 (ib);
437   r->inner = (eh_region) (intptr_t) lto_input_sleb128 (ib);
438   r->next_peer = (eh_region) (intptr_t) lto_input_sleb128 (ib);
439
440   switch (tag)
441     {
442       case LTO_ert_cleanup:
443         r->type = ERT_CLEANUP;
444         break;
445
446       case LTO_ert_try:
447         {
448           struct eh_catch_d *last_catch;
449           r->type = ERT_TRY;
450           r->u.eh_try.first_catch = lto_input_eh_catch_list (ib, data_in,
451                                                              &last_catch);
452           r->u.eh_try.last_catch = last_catch;
453           break;
454         }
455
456       case LTO_ert_allowed_exceptions:
457         {
458           tree l;
459
460           r->type = ERT_ALLOWED_EXCEPTIONS;
461           r->u.allowed.type_list = lto_input_tree (ib, data_in);
462           r->u.allowed.label = lto_input_tree (ib, data_in);
463           r->u.allowed.filter = lto_input_uleb128 (ib);
464
465           for (l = r->u.allowed.type_list; l ; l = TREE_CHAIN (l))
466             add_type_for_runtime (TREE_VALUE (l));
467         }
468         break;
469
470       case LTO_ert_must_not_throw:
471         r->type = ERT_MUST_NOT_THROW;
472         r->u.must_not_throw.failure_decl = lto_input_tree (ib, data_in);
473         r->u.must_not_throw.failure_loc = lto_input_location (ib, data_in);
474         break;
475
476       default:
477         gcc_unreachable ();
478     }
479
480   r->landing_pads = (eh_landing_pad) (intptr_t) lto_input_sleb128 (ib);
481
482   return r;
483 }
484
485
486 /* Read and return EH landing pad IX from input block IB, using descriptors
487    in DATA_IN.  */
488
489 static eh_landing_pad
490 input_eh_lp (struct lto_input_block *ib, struct data_in *data_in, int ix)
491 {
492   enum LTO_tags tag;
493   eh_landing_pad lp;
494
495   /* Read the landing pad header.  */
496   tag = input_record_start (ib);
497   if (tag == LTO_null)
498     return NULL;
499
500   lto_tag_check_range (tag, LTO_eh_landing_pad, LTO_eh_landing_pad);
501
502   lp = GGC_CNEW (struct eh_landing_pad_d);
503   lp->index = lto_input_sleb128 (ib);
504   gcc_assert (lp->index == ix);
505   lp->next_lp = (eh_landing_pad) (intptr_t) lto_input_sleb128 (ib);
506   lp->region = (eh_region) (intptr_t) lto_input_sleb128 (ib);
507   lp->post_landing_pad = lto_input_tree (ib, data_in);
508
509   return lp;
510 }
511
512
513 /* After reading the EH regions, pointers to peer and children regions
514    are region numbers.  This converts all these region numbers into
515    real pointers into the rematerialized regions for FN.  ROOT_REGION
516    is the region number for the root EH region in FN.  */
517
518 static void
519 fixup_eh_region_pointers (struct function *fn, HOST_WIDE_INT root_region)
520 {
521   unsigned i;
522   VEC(eh_region,gc) *eh_array = fn->eh->region_array;
523   VEC(eh_landing_pad,gc) *lp_array = fn->eh->lp_array;
524   eh_region r;
525   eh_landing_pad lp;
526
527   gcc_assert (eh_array && lp_array);
528
529   gcc_assert (root_region >= 0);
530   fn->eh->region_tree = VEC_index (eh_region, eh_array, root_region);
531
532 #define FIXUP_EH_REGION(r) (r) = VEC_index (eh_region, eh_array, \
533                                             (HOST_WIDE_INT) (intptr_t) (r))
534 #define FIXUP_EH_LP(p) (p) = VEC_index (eh_landing_pad, lp_array, \
535                                         (HOST_WIDE_INT) (intptr_t) (p))
536
537   /* Convert all the index numbers stored in pointer fields into
538      pointers to the corresponding slots in the EH region array.  */
539   for (i = 0; VEC_iterate (eh_region, eh_array, i, r); i++)
540     {
541       /* The array may contain NULL regions.  */
542       if (r == NULL)
543         continue;
544
545       gcc_assert (i == (unsigned) r->index);
546       FIXUP_EH_REGION (r->outer);
547       FIXUP_EH_REGION (r->inner);
548       FIXUP_EH_REGION (r->next_peer);
549       FIXUP_EH_LP (r->landing_pads);
550     }
551
552   /* Convert all the index numbers stored in pointer fields into
553      pointers to the corresponding slots in the EH landing pad array.  */
554   for (i = 0; VEC_iterate (eh_landing_pad, lp_array, i, lp); i++)
555     {
556       /* The array may contain NULL landing pads.  */
557       if (lp == NULL)
558         continue;
559
560       gcc_assert (i == (unsigned) lp->index);
561       FIXUP_EH_LP (lp->next_lp);
562       FIXUP_EH_REGION (lp->region);
563     }
564
565 #undef FIXUP_EH_REGION
566 #undef FIXUP_EH_LP
567 }
568
569
570 /* Initialize EH support.  */
571
572 static void
573 lto_init_eh (void)
574 {
575   /* Contrary to most other FEs, we only initialize EH support when at
576      least one of the files in the set contains exception regions in
577      it.  Since this happens much later than the call to init_eh in
578      lang_dependent_init, we have to set flag_exceptions and call
579      init_eh again to initialize the EH tables.  */
580   flag_exceptions = 1;
581   init_eh ();
582
583   /* Initialize dwarf2 tables.  Since dwarf2out_do_frame() returns
584      true only when exceptions are enabled, this initialization is
585      never done during lang_dependent_init.  */
586 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
587   if (dwarf2out_do_frame ())
588     dwarf2out_frame_init ();
589 #endif
590 }
591
592
593 /* Read the exception table for FN from IB using the data descriptors
594    in DATA_IN.  */
595
596 static void
597 input_eh_regions (struct lto_input_block *ib, struct data_in *data_in,
598                   struct function *fn)
599 {
600   HOST_WIDE_INT i, root_region, len;
601   enum LTO_tags tag;
602   static bool eh_initialized_p = false;
603   
604   tag = input_record_start (ib);
605   if (tag == LTO_null)
606     return;
607
608   lto_tag_check_range (tag, LTO_eh_table, LTO_eh_table);
609
610   /* If the file contains EH regions, then it was compiled with
611      -fexceptions.  In that case, initialize the backend EH
612      machinery.  */
613   if (!eh_initialized_p)
614     {
615       lto_init_eh ();
616       eh_initialized_p = true;
617     }
618
619   gcc_assert (fn->eh);
620
621   root_region = lto_input_sleb128 (ib);
622   gcc_assert (root_region == (int) root_region);
623
624   /* Read the EH region array.  */
625   len = lto_input_sleb128 (ib);
626   gcc_assert (len == (int) len);
627   if (len > 0)
628     {
629       VEC_safe_grow (eh_region, gc, fn->eh->region_array, len);
630       for (i = 0; i < len; i++)
631         {
632           eh_region r = input_eh_region (ib, data_in, i);
633           VEC_replace (eh_region, fn->eh->region_array, i, r);
634         }
635     }
636
637   /* Read the landing pads.  */
638   len = lto_input_sleb128 (ib);
639   gcc_assert (len == (int) len);
640   if (len > 0)
641     {
642       VEC_safe_grow (eh_landing_pad, gc, fn->eh->lp_array, len);
643       for (i = 0; i < len; i++)
644         {
645           eh_landing_pad lp = input_eh_lp (ib, data_in, i);
646           VEC_replace (eh_landing_pad, fn->eh->lp_array, i, lp);
647         }
648     }
649
650   /* Read the runtime type data.  */
651   len = lto_input_sleb128 (ib);
652   gcc_assert (len == (int) len);
653   if (len > 0)
654     {
655       VEC_safe_grow (tree, gc, fn->eh->ttype_data, len);
656       for (i = 0; i < len; i++)
657         {
658           tree ttype = lto_input_tree (ib, data_in);
659           VEC_replace (tree, fn->eh->ttype_data, i, ttype);
660         }
661     }
662
663   /* Read the table of action chains.  */
664   len = lto_input_sleb128 (ib);
665   gcc_assert (len == (int) len);
666   if (len > 0)
667     {
668       if (targetm.arm_eabi_unwinder)
669         {
670           VEC_safe_grow (tree, gc, fn->eh->ehspec_data.arm_eabi, len);
671           for (i = 0; i < len; i++)
672             {
673               tree t = lto_input_tree (ib, data_in);
674               VEC_replace (tree, fn->eh->ehspec_data.arm_eabi, i, t);
675             }
676         }
677       else
678         {
679           VEC_safe_grow (uchar, gc, fn->eh->ehspec_data.other, len);
680           for (i = 0; i < len; i++)
681             {
682               uchar c = lto_input_1_unsigned (ib);
683               VEC_replace (uchar, fn->eh->ehspec_data.other, i, c);
684             }
685         }
686     }
687
688   /* Reconstruct the EH region tree by fixing up the peer/children
689      pointers.  */
690   fixup_eh_region_pointers (fn, root_region);
691
692   tag = input_record_start (ib);
693   lto_tag_check_range (tag, LTO_null, LTO_null);
694 }
695
696
697 /* Make a new basic block with index INDEX in function FN.  */
698
699 static basic_block
700 make_new_block (struct function *fn, unsigned int index)
701 {
702   basic_block bb = alloc_block ();
703   bb->index = index;
704   SET_BASIC_BLOCK_FOR_FUNCTION (fn, index, bb);
705   bb->il.gimple = GGC_CNEW (struct gimple_bb_info);
706   n_basic_blocks_for_function (fn)++;
707   bb->flags = 0;
708   set_bb_seq (bb, gimple_seq_alloc ());
709   return bb;
710 }
711
712
713 /* Read the CFG for function FN from input block IB.  */
714
715 static void 
716 input_cfg (struct lto_input_block *ib, struct function *fn)
717 {
718   unsigned int bb_count;
719   basic_block p_bb;
720   unsigned int i;
721   int index;
722
723   init_empty_tree_cfg_for_function (fn);
724   init_ssa_operands ();
725
726   profile_status_for_function (fn) = 
727     (enum profile_status_d) lto_input_uleb128 (ib);
728
729   bb_count = lto_input_uleb128 (ib);
730
731   last_basic_block_for_function (fn) = bb_count;
732   if (bb_count > VEC_length (basic_block, basic_block_info_for_function (fn)))
733     VEC_safe_grow_cleared (basic_block, gc,
734                            basic_block_info_for_function (fn), bb_count);
735
736   if (bb_count > VEC_length (basic_block, label_to_block_map_for_function (fn)))
737     VEC_safe_grow_cleared (basic_block, gc, 
738                            label_to_block_map_for_function (fn), bb_count);
739
740   index = lto_input_sleb128 (ib);
741   while (index != -1)
742     {
743       basic_block bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
744       unsigned int edge_count;
745
746       if (bb == NULL)
747         bb = make_new_block (fn, index);
748
749       edge_count = lto_input_uleb128 (ib);
750
751       /* Connect up the CFG.  */
752       for (i = 0; i < edge_count; i++)
753         {
754           unsigned int dest_index;
755           unsigned int edge_flags;
756           basic_block dest;
757           int probability;
758           gcov_type count;
759           edge e;
760
761           dest_index = lto_input_uleb128 (ib);
762           probability = (int) lto_input_sleb128 (ib);
763           count = (gcov_type) lto_input_sleb128 (ib);
764           edge_flags = lto_input_uleb128 (ib);
765
766           dest = BASIC_BLOCK_FOR_FUNCTION (fn, dest_index);
767
768           if (dest == NULL) 
769             dest = make_new_block (fn, dest_index);
770
771           e = make_edge (bb, dest, edge_flags);
772           e->probability = probability;
773           e->count = count;
774         }
775
776       index = lto_input_sleb128 (ib);
777     }
778
779   p_bb = ENTRY_BLOCK_PTR_FOR_FUNCTION(fn);
780   index = lto_input_sleb128 (ib);
781   while (index != -1)
782     {
783       basic_block bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
784       bb->prev_bb = p_bb;
785       p_bb->next_bb = bb;
786       p_bb = bb;
787       index = lto_input_sleb128 (ib);
788     }
789 }
790
791
792 /* Read a PHI function for basic block BB in function FN.  DATA_IN is
793    the file being read.  IB is the input block to use for reading.  */
794
795 static gimple
796 input_phi (struct lto_input_block *ib, basic_block bb, struct data_in *data_in,
797            struct function *fn)
798 {
799   unsigned HOST_WIDE_INT ix;
800   tree phi_result;
801   int i, len;
802   gimple result;
803
804   ix = lto_input_uleb128 (ib);
805   phi_result = VEC_index (tree, SSANAMES (fn), ix);
806   len = EDGE_COUNT (bb->preds);
807   result = create_phi_node (phi_result, bb);
808   SSA_NAME_DEF_STMT (phi_result) = result;
809
810   /* We have to go through a lookup process here because the preds in the
811      reconstructed graph are generally in a different order than they
812      were in the original program.  */
813   for (i = 0; i < len; i++)
814     {
815       tree def = lto_input_tree (ib, data_in);
816       int src_index = lto_input_uleb128 (ib);
817       location_t arg_loc = lto_input_location (ib, data_in);
818       basic_block sbb = BASIC_BLOCK_FOR_FUNCTION (fn, src_index);
819       
820       edge e = NULL;
821       int j;
822       
823       for (j = 0; j < len; j++)
824         if (EDGE_PRED (bb, j)->src == sbb)
825           {
826             e = EDGE_PRED (bb, j);
827             break;
828           }
829
830       add_phi_arg (result, def, e, arg_loc); 
831     }
832
833   return result;
834 }
835
836
837 /* Read the SSA names array for function FN from DATA_IN using input
838    block IB.  */
839
840 static void
841 input_ssa_names (struct lto_input_block *ib, struct data_in *data_in,
842                  struct function *fn)
843 {
844   unsigned int i, size;
845
846   size = lto_input_uleb128 (ib);
847   init_ssanames (fn, size);
848
849   i = lto_input_uleb128 (ib);
850   while (i)
851     {
852       tree ssa_name, name;
853       bool is_default_def;
854
855       /* Skip over the elements that had been freed.  */
856       while (VEC_length (tree, SSANAMES (fn)) < i)
857         VEC_quick_push (tree, SSANAMES (fn), NULL_TREE);
858
859       is_default_def = (lto_input_1_unsigned (ib) != 0);
860       name = lto_input_tree (ib, data_in);
861       ssa_name = make_ssa_name_fn (fn, name, gimple_build_nop ());
862
863       if (is_default_def)
864         set_default_def (SSA_NAME_VAR (ssa_name), ssa_name);
865
866       i = lto_input_uleb128 (ib);
867     } 
868 }
869
870
871 /* Read a statement with tag TAG in function FN from block IB using
872    descriptors in DATA_IN.  */
873
874 static gimple
875 input_gimple_stmt (struct lto_input_block *ib, struct data_in *data_in,
876                    struct function *fn, enum LTO_tags tag)
877 {
878   gimple stmt;
879   enum gimple_code code;
880   unsigned HOST_WIDE_INT num_ops;
881   size_t i;
882   struct bitpack_d *bp;
883
884   code = lto_tag_to_gimple_code (tag);
885
886   /* Read the tuple header.  */
887   bp = lto_input_bitpack (ib);
888   num_ops = bp_unpack_value (bp, sizeof (unsigned) * 8);
889   stmt = gimple_alloc (code, num_ops);
890   stmt->gsbase.no_warning = bp_unpack_value (bp, 1);
891   if (is_gimple_assign (stmt))
892     stmt->gsbase.nontemporal_move = bp_unpack_value (bp, 1);
893   stmt->gsbase.has_volatile_ops = bp_unpack_value (bp, 1);
894   stmt->gsbase.subcode = bp_unpack_value (bp, 16);
895   bitpack_delete (bp);
896
897   /* Read location information.  */
898   gimple_set_location (stmt, lto_input_location (ib, data_in));
899
900   /* Read lexical block reference.  */
901   gimple_set_block (stmt, lto_input_tree (ib, data_in));
902
903   /* Read in all the operands.  */
904   switch (code)
905     {
906     case GIMPLE_RESX:
907       gimple_resx_set_region (stmt, lto_input_sleb128 (ib));
908       break;
909
910     case GIMPLE_EH_MUST_NOT_THROW:
911       gimple_eh_must_not_throw_set_fndecl (stmt, lto_input_tree (ib, data_in));
912       break;
913
914     case GIMPLE_EH_DISPATCH:
915       gimple_eh_dispatch_set_region (stmt, lto_input_sleb128 (ib));
916       break;
917
918     case GIMPLE_ASM:
919       {
920         /* FIXME lto.  Move most of this into a new gimple_asm_set_string().  */
921         tree str;
922         stmt->gimple_asm.ni = lto_input_uleb128 (ib);
923         stmt->gimple_asm.no = lto_input_uleb128 (ib);
924         stmt->gimple_asm.nc = lto_input_uleb128 (ib);
925         str = input_string_cst (data_in, ib);
926         stmt->gimple_asm.string = TREE_STRING_POINTER (str);
927       }
928       /* Fallthru  */
929
930     case GIMPLE_ASSIGN:
931     case GIMPLE_CALL:
932     case GIMPLE_RETURN:
933     case GIMPLE_SWITCH:
934     case GIMPLE_LABEL:
935     case GIMPLE_COND:
936     case GIMPLE_GOTO:
937     case GIMPLE_DEBUG:
938       for (i = 0; i < num_ops; i++)
939         {
940           tree op = lto_input_tree (ib, data_in);
941           gimple_set_op (stmt, i, op);
942         }
943       break;
944
945     case GIMPLE_NOP:
946     case GIMPLE_PREDICT:
947       break;
948
949     default:
950       internal_error ("bytecode stream: unknown GIMPLE statement tag %s",
951                       lto_tag_name (tag));
952     }
953
954   /* Update the properties of symbols, SSA names and labels associated
955      with STMT.  */
956   if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)
957     {
958       tree lhs = gimple_get_lhs (stmt);
959       if (lhs && TREE_CODE (lhs) == SSA_NAME)
960         SSA_NAME_DEF_STMT (lhs) = stmt;
961     }
962   else if (code == GIMPLE_LABEL)
963     gcc_assert (emit_label_in_global_context_p (gimple_label_label (stmt))
964                 || DECL_CONTEXT (gimple_label_label (stmt)) == fn->decl);
965   else if (code == GIMPLE_ASM)
966     {
967       unsigned i;
968
969       for (i = 0; i < gimple_asm_noutputs (stmt); i++)
970         {
971           tree op = TREE_VALUE (gimple_asm_output_op (stmt, i));
972           if (TREE_CODE (op) == SSA_NAME)
973             SSA_NAME_DEF_STMT (op) = stmt;
974         }
975     }
976
977   /* Mark the statement modified so its operand vectors can be filled in.  */
978   gimple_set_modified (stmt, true);
979
980   return stmt;
981 }
982
983  
984 /* Read a basic block with tag TAG from DATA_IN using input block IB.
985    FN is the function being processed.  */
986
987 static void
988 input_bb (struct lto_input_block *ib, enum LTO_tags tag, 
989           struct data_in *data_in, struct function *fn)
990 {
991   unsigned int index;
992   basic_block bb;
993   gimple_stmt_iterator bsi;
994
995   /* This routine assumes that CFUN is set to FN, as it needs to call
996      basic GIMPLE routines that use CFUN.  */
997   gcc_assert (cfun == fn);
998
999   index = lto_input_uleb128 (ib);
1000   bb = BASIC_BLOCK_FOR_FUNCTION (fn, index);
1001
1002   bb->count = lto_input_sleb128 (ib);
1003   bb->loop_depth = lto_input_sleb128 (ib);
1004   bb->frequency = lto_input_sleb128 (ib);
1005   bb->flags = lto_input_sleb128 (ib);
1006
1007   /* LTO_bb1 has statements.  LTO_bb0 does not.  */
1008   if (tag == LTO_bb0)
1009     return;
1010
1011   bsi = gsi_start_bb (bb);
1012   tag = input_record_start (ib);
1013   while (tag)
1014     {
1015       gimple stmt = input_gimple_stmt (ib, data_in, fn, tag);
1016
1017       /* Drop debug stmts on-the-fly if we do not have VTA enabled.
1018          This allows us to build for example static libs with debugging
1019          enabled and do the final link without.  */
1020       if (MAY_HAVE_DEBUG_STMTS
1021           || !is_gimple_debug (stmt))
1022         {
1023           find_referenced_vars_in (stmt);
1024           gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
1025         }
1026
1027       /* After the statement, expect a 0 delimiter or the EH region
1028          that the previous statement belongs to.  */
1029       tag = input_record_start (ib);
1030       lto_tag_check_set (tag, 2, LTO_eh_region, LTO_null);
1031
1032       if (tag == LTO_eh_region)
1033         {
1034           HOST_WIDE_INT region = lto_input_sleb128 (ib);
1035           gcc_assert (region == (int) region);
1036           if (MAY_HAVE_DEBUG_STMTS || !is_gimple_debug (stmt))
1037             add_stmt_to_eh_lp (stmt, region);
1038         }
1039
1040       tag = input_record_start (ib);
1041     }
1042
1043   tag = input_record_start (ib);
1044   while (tag)
1045     {
1046       gimple phi = input_phi (ib, bb, data_in, fn);
1047       find_referenced_vars_in (phi);
1048       tag = input_record_start (ib);
1049     }
1050 }
1051
1052 /* Go through all NODE edges and fixup call_stmt pointers
1053    so they point to STMTS.  */
1054
1055 static void
1056 fixup_call_stmt_edges_1 (struct cgraph_node *node, gimple *stmts)
1057 {
1058   struct cgraph_edge *cedge;
1059   for (cedge = node->callees; cedge; cedge = cedge->next_callee)
1060     cedge->call_stmt = stmts[cedge->lto_stmt_uid];
1061 }
1062
1063 /* Fixup call_stmt pointers in NODE and all clones.  */
1064
1065 static void
1066 fixup_call_stmt_edges (struct cgraph_node *orig, gimple *stmts)
1067 {
1068   struct cgraph_node *node;
1069
1070   while (orig->clone_of)
1071     orig = orig->clone_of;
1072
1073   fixup_call_stmt_edges_1 (orig, stmts);
1074   if (orig->clones)
1075     for (node = orig->clones; node != orig;)
1076       {
1077         fixup_call_stmt_edges_1 (node, stmts);
1078         if (node->clones)
1079           node = node->clones;
1080         else if (node->next_sibling_clone)
1081           node = node->next_sibling_clone;
1082         else
1083           {
1084             while (node != orig && !node->next_sibling_clone)
1085               node = node->clone_of;
1086             if (node != orig)
1087               node = node->next_sibling_clone;
1088           }
1089       }
1090 }
1091
1092 /* Read the body of function FN_DECL from DATA_IN using input block IB.  */
1093
1094 static void
1095 input_function (tree fn_decl, struct data_in *data_in, 
1096                 struct lto_input_block *ib)
1097 {
1098   struct function *fn;
1099   enum LTO_tags tag;
1100   gimple *stmts;
1101   basic_block bb;
1102   struct bitpack_d *bp;
1103
1104   fn = DECL_STRUCT_FUNCTION (fn_decl);
1105   tag = input_record_start (ib);
1106   clear_line_info (data_in);
1107
1108   gimple_register_cfg_hooks ();
1109   lto_tag_check (tag, LTO_function);
1110
1111   /* Read all the attributes for FN.  */
1112   bp = lto_input_bitpack (ib);
1113   fn->is_thunk = bp_unpack_value (bp, 1);
1114   fn->has_local_explicit_reg_vars = bp_unpack_value (bp, 1);
1115   fn->after_tree_profile = bp_unpack_value (bp, 1);
1116   fn->returns_pcc_struct = bp_unpack_value (bp, 1);
1117   fn->returns_struct = bp_unpack_value (bp, 1);
1118   fn->always_inline_functions_inlined = bp_unpack_value (bp, 1);
1119   fn->after_inlining = bp_unpack_value (bp, 1);
1120   fn->dont_save_pending_sizes_p = bp_unpack_value (bp, 1);
1121   fn->stdarg = bp_unpack_value (bp, 1);
1122   fn->has_nonlocal_label = bp_unpack_value (bp, 1);
1123   fn->calls_alloca = bp_unpack_value (bp, 1);
1124   fn->calls_setjmp = bp_unpack_value (bp, 1);
1125   fn->function_frequency = (enum function_frequency) bp_unpack_value (bp, 2);
1126   fn->va_list_fpr_size = bp_unpack_value (bp, 8);
1127   fn->va_list_gpr_size = bp_unpack_value (bp, 8);
1128   bitpack_delete (bp);
1129
1130   /* Read the static chain and non-local goto save area.  */
1131   fn->static_chain_decl = lto_input_tree (ib, data_in);
1132   fn->nonlocal_goto_save_area = lto_input_tree (ib, data_in);
1133
1134   /* Read all the local symbols.  */
1135   fn->local_decls = lto_input_tree (ib, data_in);
1136
1137   /* Read all the SSA names.  */
1138   input_ssa_names (ib, data_in, fn);
1139
1140   /* Read the exception handling regions in the function.  */
1141   input_eh_regions (ib, data_in, fn);
1142
1143   /* Read the tree of lexical scopes for the function.  */
1144   DECL_INITIAL (fn_decl) = lto_input_tree (ib, data_in);
1145   gcc_assert (DECL_INITIAL (fn_decl));
1146   DECL_SAVED_TREE (fn_decl) = NULL_TREE;
1147
1148   /* Read all function arguments.  */
1149   DECL_ARGUMENTS (fn_decl) = lto_input_tree (ib, data_in); 
1150
1151   /* Read all the basic blocks.  */
1152   tag = input_record_start (ib);
1153   while (tag)
1154     {
1155       input_bb (ib, tag, data_in, fn);
1156       tag = input_record_start (ib);
1157     }
1158
1159   /* Fix up the call statements that are mentioned in the callgraph
1160      edges.  */
1161   renumber_gimple_stmt_uids ();
1162   stmts = (gimple *) xcalloc (gimple_stmt_max_uid (fn), sizeof (gimple));
1163   FOR_ALL_BB (bb)
1164     {
1165       gimple_stmt_iterator bsi;
1166       for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi))
1167         {
1168           gimple stmt = gsi_stmt (bsi);
1169           stmts[gimple_uid (stmt)] = stmt;
1170         }
1171     }
1172
1173   /* Set the gimple body to the statement sequence in the entry
1174      basic block.  FIXME lto, this is fairly hacky.  The existence
1175      of a gimple body is used by the cgraph routines, but we should
1176      really use the presence of the CFG.  */
1177   {
1178     edge_iterator ei = ei_start (ENTRY_BLOCK_PTR->succs);
1179     gimple_set_body (fn_decl, bb_seq (ei_edge (ei)->dest));
1180   }
1181
1182   fixup_call_stmt_edges (cgraph_node (fn_decl), stmts);
1183
1184   update_ssa (TODO_update_ssa_only_virtuals); 
1185   free (stmts);
1186 }
1187
1188
1189 /* Read initializer expressions for public statics.  DATA_IN is the
1190    file being read.  IB is the input block used for reading.  */
1191
1192 static void
1193 input_alias_pairs (struct lto_input_block *ib, struct data_in *data_in)
1194 {
1195   tree var;
1196
1197   clear_line_info (data_in);
1198
1199   /* Skip over all the unreferenced globals.  */
1200   do
1201     var = lto_input_tree (ib, data_in);
1202   while (var);
1203
1204   var = lto_input_tree (ib, data_in);
1205   while (var)
1206     {
1207       const char *orig_name, *new_name;
1208       alias_pair *p;
1209       
1210       p = VEC_safe_push (alias_pair, gc, alias_pairs, NULL);
1211       p->decl = var;
1212       p->target = lto_input_tree (ib, data_in);
1213
1214       /* If the target is a static object, we may have registered a
1215          new name for it to avoid clashes between statics coming from
1216          different files.  In that case, use the new name.  */
1217       orig_name = IDENTIFIER_POINTER (p->target);
1218       new_name = lto_get_decl_name_mapping (data_in->file_data, orig_name);
1219       if (strcmp (orig_name, new_name) != 0)
1220         p->target = get_identifier (new_name);
1221
1222       var = lto_input_tree (ib, data_in);
1223     }
1224 }
1225
1226
1227 /* Read the body from DATA for function FN_DECL and fill it in.
1228    FILE_DATA are the global decls and types.  SECTION_TYPE is either
1229    LTO_section_function_body or LTO_section_static_initializer.  If
1230    section type is LTO_section_function_body, FN must be the decl for
1231    that function.  */
1232
1233 static void 
1234 lto_read_body (struct lto_file_decl_data *file_data, tree fn_decl,
1235                const char *data, enum lto_section_type section_type)
1236 {
1237   const struct lto_function_header *header;
1238   struct data_in *data_in;
1239   int32_t cfg_offset;
1240   int32_t main_offset;
1241   int32_t string_offset;
1242   struct lto_input_block ib_cfg;
1243   struct lto_input_block ib_main;
1244
1245   header = (const struct lto_function_header *) data;
1246   cfg_offset = sizeof (struct lto_function_header); 
1247   main_offset = cfg_offset + header->cfg_size;
1248   string_offset = main_offset + header->main_size;
1249
1250   LTO_INIT_INPUT_BLOCK (ib_cfg,
1251                         data + cfg_offset,
1252                         0,
1253                         header->cfg_size);
1254
1255   LTO_INIT_INPUT_BLOCK (ib_main,
1256                         data + main_offset,
1257                         0,
1258                         header->main_size);
1259   
1260   data_in = lto_data_in_create (file_data, data + string_offset,
1261                                 header->string_size, NULL);
1262
1263   /* Make sure the file was generated by the exact same compiler.  */
1264   lto_check_version (header->lto_header.major_version,
1265                      header->lto_header.minor_version);
1266
1267   if (section_type == LTO_section_function_body)
1268     {
1269       struct function *fn = DECL_STRUCT_FUNCTION (fn_decl);
1270       struct lto_in_decl_state *decl_state;
1271
1272       push_cfun (fn);
1273       init_tree_ssa (fn);
1274
1275       /* Use the function's decl state. */
1276       decl_state = lto_get_function_in_decl_state (file_data, fn_decl);
1277       gcc_assert (decl_state);
1278       file_data->current_decl_state = decl_state;
1279
1280       input_cfg (&ib_cfg, fn);
1281
1282       /* Set up the struct function.  */
1283       input_function (fn_decl, data_in, &ib_main);
1284
1285       /* We should now be in SSA.  */
1286       cfun->gimple_df->in_ssa_p = true;
1287
1288       /* Fill in properties we know hold for the rebuilt CFG.  */
1289       cfun->curr_properties = PROP_ssa
1290                               | PROP_cfg
1291                               | PROP_gimple_any
1292                               | PROP_gimple_lcf
1293                               | PROP_gimple_leh
1294                               | PROP_referenced_vars;
1295
1296       /* Restore decl state */
1297       file_data->current_decl_state = file_data->global_decl_state;
1298
1299       pop_cfun ();
1300     }
1301   else 
1302     {
1303       input_alias_pairs (&ib_main, data_in);
1304     }
1305
1306   clear_line_info (data_in);
1307   lto_data_in_delete (data_in);
1308 }
1309
1310
1311 /* Read the body of FN_DECL using DATA.  FILE_DATA holds the global
1312    decls and types.  */
1313
1314 void 
1315 lto_input_function_body (struct lto_file_decl_data *file_data,
1316                          tree fn_decl, const char *data)
1317 {
1318   current_function_decl = fn_decl;
1319   lto_read_body (file_data, fn_decl, data, LTO_section_function_body);
1320 }
1321
1322
1323 /* Read in VAR_DECL using DATA.  FILE_DATA holds the global decls and
1324    types.  */
1325
1326 void 
1327 lto_input_constructors_and_inits (struct lto_file_decl_data *file_data,
1328                                   const char *data)
1329 {
1330   lto_read_body (file_data, NULL, data, LTO_section_static_initializer);
1331 }
1332
1333
1334 /* Return the resolution for the decl with index INDEX from DATA_IN. */
1335
1336 static enum ld_plugin_symbol_resolution
1337 get_resolution (struct data_in *data_in, unsigned index)
1338 {
1339   if (data_in->globals_resolution)
1340     {
1341       ld_plugin_symbol_resolution_t ret;
1342       gcc_assert (index < VEC_length (ld_plugin_symbol_resolution_t,
1343                                       data_in->globals_resolution));
1344       ret = VEC_index (ld_plugin_symbol_resolution_t,
1345                        data_in->globals_resolution,
1346                        index);
1347       gcc_assert (ret != LDPR_UNKNOWN);
1348       return ret;
1349     }
1350   else
1351     /* Delay resolution finding until decl merging.  */
1352     return LDPR_UNKNOWN;
1353 }
1354
1355
1356 /* Unpack all the non-pointer fields of the TS_BASE structure of
1357    expression EXPR from bitpack BP.  */
1358
1359 static void
1360 unpack_ts_base_value_fields (struct bitpack_d *bp, tree expr)
1361 {
1362   /* Note that the code for EXPR has already been unpacked to create EXPR in
1363      lto_materialize_tree.  */
1364   if (!TYPE_P (expr))
1365     {
1366       TREE_SIDE_EFFECTS (expr) = (unsigned) bp_unpack_value (bp, 1);
1367       TREE_CONSTANT (expr) = (unsigned) bp_unpack_value (bp, 1);
1368       TREE_READONLY (expr) = (unsigned) bp_unpack_value (bp, 1);
1369
1370       /* TREE_PUBLIC is used on types to indicate that the type
1371          has a TYPE_CACHED_VALUES vector.  This is not streamed out,
1372          so we skip it here.  */
1373       TREE_PUBLIC (expr) = (unsigned) bp_unpack_value (bp, 1);
1374     }
1375   TREE_ADDRESSABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
1376   TREE_THIS_VOLATILE (expr) = (unsigned) bp_unpack_value (bp, 1);
1377   if (DECL_P (expr))
1378     DECL_UNSIGNED (expr) = (unsigned) bp_unpack_value (bp, 1);
1379   else if (TYPE_P (expr))
1380     TYPE_UNSIGNED (expr) = (unsigned) bp_unpack_value (bp, 1);
1381   TREE_ASM_WRITTEN (expr) = (unsigned) bp_unpack_value (bp, 1);
1382   TREE_NO_WARNING (expr) = (unsigned) bp_unpack_value (bp, 1);
1383   TREE_USED (expr) = (unsigned) bp_unpack_value (bp, 1);
1384   TREE_NOTHROW (expr) = (unsigned) bp_unpack_value (bp, 1);
1385   TREE_STATIC (expr) = (unsigned) bp_unpack_value (bp, 1);
1386   TREE_PRIVATE (expr) = (unsigned) bp_unpack_value (bp, 1);
1387   TREE_PROTECTED (expr) = (unsigned) bp_unpack_value (bp, 1);
1388   TREE_DEPRECATED (expr) = (unsigned) bp_unpack_value (bp, 1);
1389   if (TYPE_P (expr))
1390     TYPE_SATURATING (expr) = (unsigned) bp_unpack_value (bp, 1);
1391   if (TREE_CODE (expr) == SSA_NAME)
1392     SSA_NAME_IS_DEFAULT_DEF (expr) = (unsigned) bp_unpack_value (bp, 1);
1393 }
1394
1395
1396 /* Unpack all the non-pointer fields of the TS_REAL_CST structure of
1397    expression EXPR from bitpack BP.  */
1398
1399 static void
1400 unpack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
1401 {
1402   unsigned i;
1403   REAL_VALUE_TYPE r;
1404   REAL_VALUE_TYPE *rp;
1405   
1406   r.cl = (unsigned) bp_unpack_value (bp, 2);
1407   r.decimal = (unsigned) bp_unpack_value (bp, 1);
1408   r.sign = (unsigned) bp_unpack_value (bp, 1);
1409   r.signalling = (unsigned) bp_unpack_value (bp, 1);
1410   r.canonical = (unsigned) bp_unpack_value (bp, 1);
1411   r.uexp = (unsigned) bp_unpack_value (bp, EXP_BITS);
1412   for (i = 0; i < SIGSZ; i++)
1413     r.sig[i] = (unsigned long) bp_unpack_value (bp, HOST_BITS_PER_LONG);
1414
1415   rp = GGC_NEW (REAL_VALUE_TYPE);
1416   memcpy (rp, &r, sizeof (REAL_VALUE_TYPE));
1417   TREE_REAL_CST_PTR (expr) = rp;
1418 }
1419
1420
1421 /* Unpack all the non-pointer fields of the TS_FIXED_CST structure of
1422    expression EXPR from bitpack BP.  */
1423
1424 static void
1425 unpack_ts_fixed_cst_value_fields (struct bitpack_d *bp, tree expr)
1426 {
1427   struct fixed_value fv;
1428   
1429   fv.data.low = (HOST_WIDE_INT) bp_unpack_value (bp, HOST_BITS_PER_WIDE_INT);
1430   fv.data.high = (HOST_WIDE_INT) bp_unpack_value (bp, HOST_BITS_PER_WIDE_INT);
1431   TREE_FIXED_CST (expr) = fv;
1432 }
1433
1434
1435 /* Unpack all the non-pointer fields of the TS_DECL_COMMON structure
1436    of expression EXPR from bitpack BP.  */
1437
1438 static void
1439 unpack_ts_decl_common_value_fields (struct bitpack_d *bp, tree expr)
1440 {
1441   DECL_MODE (expr) = (enum machine_mode) bp_unpack_value (bp, 8);
1442   DECL_NONLOCAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1443   DECL_VIRTUAL_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1444   DECL_IGNORED_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1445   DECL_ABSTRACT (expr) = (unsigned) bp_unpack_value (bp, 1);
1446   DECL_ARTIFICIAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1447   DECL_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1);
1448   DECL_PRESERVE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1449   DECL_DEBUG_EXPR_IS_FROM (expr) = (unsigned) bp_unpack_value (bp, 1);
1450   DECL_EXTERNAL (expr) = (unsigned) bp_unpack_value (bp, 1);
1451   DECL_GIMPLE_REG_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1452   DECL_ALIGN (expr) = (unsigned) bp_unpack_value (bp, HOST_BITS_PER_INT);
1453
1454   if (TREE_CODE (expr) == LABEL_DECL)
1455     {
1456       DECL_ERROR_ISSUED (expr) = (unsigned) bp_unpack_value (bp, 1);
1457       EH_LANDING_PAD_NR (expr) = (int) bp_unpack_value (bp, HOST_BITS_PER_INT);
1458
1459       /* Always assume an initial value of -1 for LABEL_DECL_UID to
1460          force gimple_set_bb to recreate label_to_block_map.  */
1461       LABEL_DECL_UID (expr) = -1;
1462     }
1463
1464   if (TREE_CODE (expr) == FIELD_DECL)
1465     {
1466       unsigned HOST_WIDE_INT off_align;
1467       DECL_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
1468       DECL_NONADDRESSABLE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1469       off_align = (unsigned HOST_WIDE_INT) bp_unpack_value (bp, 8);
1470       SET_DECL_OFFSET_ALIGN (expr, off_align);
1471     }
1472
1473   if (TREE_CODE (expr) == RESULT_DECL
1474       || TREE_CODE (expr) == PARM_DECL
1475       || TREE_CODE (expr) == VAR_DECL)
1476     {
1477       DECL_BY_REFERENCE (expr) = (unsigned) bp_unpack_value (bp, 1);
1478       if (TREE_CODE (expr) == VAR_DECL
1479           || TREE_CODE (expr) == PARM_DECL)
1480         DECL_HAS_VALUE_EXPR_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1481     }
1482 }
1483
1484
1485 /* Unpack all the non-pointer fields of the TS_DECL_WRTL structure
1486    of expression EXPR from bitpack BP.  */
1487
1488 static void
1489 unpack_ts_decl_wrtl_value_fields (struct bitpack_d *bp, tree expr)
1490 {
1491   DECL_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
1492 }
1493
1494
1495 /* Unpack all the non-pointer fields of the TS_DECL_WITH_VIS structure
1496    of expression EXPR from bitpack BP.  */
1497
1498 static void
1499 unpack_ts_decl_with_vis_value_fields (struct bitpack_d *bp, tree expr)
1500 {
1501   DECL_DEFER_OUTPUT (expr) = (unsigned) bp_unpack_value (bp, 1);
1502   DECL_COMMON (expr) = (unsigned) bp_unpack_value (bp, 1);
1503   DECL_DLLIMPORT_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1504   DECL_WEAK (expr) = (unsigned) bp_unpack_value (bp, 1);
1505   DECL_SEEN_IN_BIND_EXPR_P (expr) = (unsigned) bp_unpack_value (bp,  1);
1506   DECL_COMDAT (expr) = (unsigned) bp_unpack_value (bp,  1);
1507   DECL_VISIBILITY (expr) = (enum symbol_visibility) bp_unpack_value (bp,  2);
1508   DECL_VISIBILITY_SPECIFIED (expr) = (unsigned) bp_unpack_value (bp,  1);
1509
1510   if (TREE_CODE (expr) == VAR_DECL)
1511     {
1512       DECL_HARD_REGISTER (expr) = (unsigned) bp_unpack_value (bp, 1);
1513       DECL_IN_TEXT_SECTION (expr) = (unsigned) bp_unpack_value (bp, 1);
1514       DECL_TLS_MODEL (expr) = (enum tls_model) bp_unpack_value (bp,  3);
1515     }
1516
1517   if (VAR_OR_FUNCTION_DECL_P (expr))
1518     {
1519       priority_type p;
1520       p = (priority_type) bp_unpack_value (bp, HOST_BITS_PER_SHORT);
1521       SET_DECL_INIT_PRIORITY (expr, p);
1522     }
1523 }
1524
1525
1526 /* Unpack all the non-pointer fields of the TS_FUNCTION_DECL structure
1527    of expression EXPR from bitpack BP.  */
1528
1529 static void
1530 unpack_ts_function_decl_value_fields (struct bitpack_d *bp, tree expr)
1531 {
1532   DECL_FUNCTION_CODE (expr) = (enum built_in_function) bp_unpack_value (bp, 11);
1533   DECL_BUILT_IN_CLASS (expr) = (enum built_in_class) bp_unpack_value (bp, 2);
1534   DECL_STATIC_CONSTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
1535   DECL_STATIC_DESTRUCTOR (expr) = (unsigned) bp_unpack_value (bp, 1);
1536   DECL_UNINLINABLE (expr) = (unsigned) bp_unpack_value (bp, 1);
1537   DECL_POSSIBLY_INLINED (expr) = (unsigned) bp_unpack_value (bp, 1);
1538   DECL_IS_NOVOPS (expr) = (unsigned) bp_unpack_value (bp, 1);
1539   DECL_IS_RETURNS_TWICE (expr) = (unsigned) bp_unpack_value (bp, 1);
1540   DECL_IS_MALLOC (expr) = (unsigned) bp_unpack_value (bp, 1);
1541   DECL_IS_OPERATOR_NEW (expr) = (unsigned) bp_unpack_value (bp, 1);
1542   DECL_DECLARED_INLINE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1543   DECL_STATIC_CHAIN (expr) = (unsigned) bp_unpack_value (bp, 1);
1544   DECL_NO_INLINE_WARNING_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1545   DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (expr)
1546                         = (unsigned) bp_unpack_value (bp, 1);
1547   DECL_NO_LIMIT_STACK (expr) = (unsigned) bp_unpack_value (bp, 1);
1548   DECL_DISREGARD_INLINE_LIMITS (expr) = (unsigned) bp_unpack_value (bp, 1);
1549   DECL_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1550   DECL_LOOPING_CONST_OR_PURE_P (expr) = (unsigned) bp_unpack_value (bp, 1);
1551 }
1552
1553
1554 /* Unpack all the non-pointer fields of the TS_TYPE structure
1555    of expression EXPR from bitpack BP.  */
1556
1557 static void
1558 unpack_ts_type_value_fields (struct bitpack_d *bp, tree expr)
1559 {
1560   enum machine_mode mode;
1561
1562   TYPE_PRECISION (expr) = (unsigned) bp_unpack_value (bp, 9);
1563   mode = (enum machine_mode) bp_unpack_value (bp, 7);
1564   SET_TYPE_MODE (expr, mode);
1565   TYPE_STRING_FLAG (expr) = (unsigned) bp_unpack_value (bp, 1);
1566   TYPE_NO_FORCE_BLK (expr) = (unsigned) bp_unpack_value (bp, 1);
1567   TYPE_NEEDS_CONSTRUCTING(expr) = (unsigned) bp_unpack_value (bp, 1);
1568   if (TREE_CODE (expr) == UNION_TYPE)
1569     TYPE_TRANSPARENT_UNION (expr) = (unsigned) bp_unpack_value (bp, 1);
1570   TYPE_PACKED (expr) = (unsigned) bp_unpack_value (bp, 1);
1571   TYPE_RESTRICT (expr) = (unsigned) bp_unpack_value (bp, 1);
1572   TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)
1573         = (unsigned) bp_unpack_value (bp, 2);
1574   TYPE_USER_ALIGN (expr) = (unsigned) bp_unpack_value (bp, 1);
1575   TYPE_READONLY (expr) = (unsigned) bp_unpack_value (bp, 1);
1576   TYPE_ALIGN (expr) = (unsigned) bp_unpack_value (bp, HOST_BITS_PER_INT);
1577   TYPE_ALIAS_SET (expr) = bp_unpack_value (bp, HOST_BITS_PER_INT);
1578 }
1579
1580
1581 /* Unpack all the non-pointer fields of the TS_BLOCK structure
1582    of expression EXPR from bitpack BP.  */
1583
1584 static void
1585 unpack_ts_block_value_fields (struct bitpack_d *bp, tree expr)
1586 {
1587   BLOCK_ABSTRACT (expr) = (unsigned) bp_unpack_value (bp, 1);
1588   BLOCK_NUMBER (expr) = (unsigned) bp_unpack_value (bp, 31);
1589 }
1590
1591
1592 /* Unpack all the non-pointer fields in EXPR into a bit pack.  */
1593
1594 static void
1595 unpack_value_fields (struct bitpack_d *bp, tree expr)
1596 {
1597   enum tree_code code;
1598
1599   code = TREE_CODE (expr);
1600
1601   /* Note that all these functions are highly sensitive to changes in
1602      the types and sizes of each of the fields being packed.  */
1603   unpack_ts_base_value_fields (bp, expr);
1604
1605   if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST))
1606     unpack_ts_real_cst_value_fields (bp, expr);
1607
1608   if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST))
1609     unpack_ts_fixed_cst_value_fields (bp, expr);
1610
1611   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
1612     unpack_ts_decl_common_value_fields (bp, expr);
1613
1614   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL))
1615     unpack_ts_decl_wrtl_value_fields (bp, expr);
1616
1617   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
1618     unpack_ts_decl_with_vis_value_fields (bp, expr);
1619
1620   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
1621     unpack_ts_function_decl_value_fields (bp, expr);
1622
1623   if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
1624     unpack_ts_type_value_fields (bp, expr);
1625
1626   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
1627     unpack_ts_block_value_fields (bp, expr);
1628
1629   if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
1630     {
1631       /* We only stream the version number of SSA names.  */
1632       gcc_unreachable ();
1633     }
1634
1635   if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
1636     {
1637       /* This is only used by GENERIC.  */
1638       gcc_unreachable ();
1639     }
1640
1641   if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
1642     {
1643       /* This is only used by High GIMPLE.  */
1644       gcc_unreachable ();
1645     }
1646 }
1647
1648
1649 /* Read a bitpack from input block IB.  */
1650
1651 struct bitpack_d *
1652 lto_input_bitpack (struct lto_input_block *ib)
1653 {
1654   unsigned i, num_words;
1655   struct bitpack_d *bp;
1656
1657   bp = bitpack_create ();
1658
1659   /* If we are about to read more than a handful of words, something
1660      is wrong.  This check is overly strict, but it acts as an early
1661      warning.  No streamed object has hundreds of bits in its fields.  */
1662   num_words = lto_input_uleb128 (ib);
1663   gcc_assert (num_words < 20);
1664
1665   for (i = 0; i < num_words; i++)
1666     {
1667       bitpack_word_t w = lto_input_uleb128 (ib);
1668       VEC_safe_push (bitpack_word_t, heap, bp->values, w);
1669     }
1670
1671   return bp;
1672 }
1673
1674
1675 /* Materialize a new tree from input block IB using descriptors in
1676    DATA_IN.  The code for the new tree should match TAG.  Store in
1677    *IX_P the index into the reader cache where the new tree is stored.  */
1678
1679 static tree
1680 lto_materialize_tree (struct lto_input_block *ib, struct data_in *data_in,
1681                       enum LTO_tags tag, int *ix_p)
1682 {
1683   struct bitpack_d *bp;
1684   enum tree_code code;
1685   tree result;
1686 #ifdef LTO_STREAMER_DEBUG
1687   HOST_WIDEST_INT orig_address_in_writer;
1688 #endif
1689   HOST_WIDE_INT ix;
1690
1691   result = NULL_TREE;
1692
1693   /* Read the header of the node we are about to create.  */
1694   ix = lto_input_sleb128 (ib);
1695   gcc_assert ((int) ix == ix);
1696   *ix_p = (int) ix;
1697
1698 #ifdef LTO_STREAMER_DEBUG
1699   /* Read the word representing the memory address for the tree
1700      as it was written by the writer.  This is useful when
1701      debugging differences between the writer and reader.  */
1702   orig_address_in_writer = lto_input_sleb128 (ib);
1703   gcc_assert ((intptr_t) orig_address_in_writer == orig_address_in_writer);
1704 #endif
1705
1706   code = lto_tag_to_tree_code (tag);
1707
1708   /* We should never see an SSA_NAME tree.  Only the version numbers of
1709      SSA names are ever written out.  See input_ssa_names.  */
1710   gcc_assert (code != SSA_NAME);
1711
1712   /* Instantiate a new tree using the header data.  */
1713   if (CODE_CONTAINS_STRUCT (code, TS_STRING))
1714     result = input_string_cst (data_in, ib);
1715   else if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER))
1716     result = input_identifier (data_in, ib);
1717   else if (CODE_CONTAINS_STRUCT (code, TS_VEC))
1718     {
1719       HOST_WIDE_INT len = lto_input_sleb128 (ib);
1720       result = make_tree_vec (len);
1721     }
1722   else if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
1723     {
1724       unsigned HOST_WIDE_INT len = lto_input_uleb128 (ib);
1725       result = make_tree_binfo (len);
1726     }
1727   else
1728     {
1729       /* All other nodes can be materialized with a raw make_node
1730          call.  */
1731       result = make_node (code);
1732     }
1733
1734 #ifdef LTO_STREAMER_DEBUG
1735   /* Store the original address of the tree as seen by the writer
1736      in RESULT's aux field.  This is useful when debugging streaming
1737      problems.  This way, a debugging session can be started on
1738      both writer and reader with a breakpoint using this address
1739      value in both.  */
1740   lto_orig_address_map (result, (intptr_t) orig_address_in_writer);
1741 #endif
1742
1743   /* Read the bitpack of non-pointer values from IB.  */
1744   bp = lto_input_bitpack (ib);
1745
1746   /* The first word in BP contains the code of the tree that we
1747      are about to read.  */
1748   code = (enum tree_code) bp_unpack_value (bp, 16);
1749   lto_tag_check (lto_tree_code_to_tag (code), tag);
1750
1751   /* Unpack all the value fields from BP.  */
1752   unpack_value_fields (bp, result);
1753   bitpack_delete (bp);
1754
1755   /* Enter RESULT in the reader cache.  This will make RESULT
1756      available so that circular references in the rest of the tree
1757      structure can be resolved in subsequent calls to lto_input_tree.  */
1758   lto_streamer_cache_insert_at (data_in->reader_cache, result, ix);
1759
1760   return result;
1761 }
1762
1763
1764 /* Read a chain of tree nodes from input block IB. DATA_IN contains
1765    tables and descriptors for the file being read.  */
1766
1767 static tree
1768 lto_input_chain (struct lto_input_block *ib, struct data_in *data_in)
1769 {
1770   int i, count;
1771   tree first, prev, curr;
1772   
1773   first = prev = NULL_TREE;
1774   count = lto_input_sleb128 (ib);
1775   for (i = 0; i < count; i++)
1776     {
1777       curr = lto_input_tree (ib, data_in);
1778       if (prev)
1779         TREE_CHAIN (prev) = curr;
1780       else
1781         first = curr;
1782
1783       TREE_CHAIN (curr) = NULL_TREE;
1784       prev = curr;
1785     }
1786
1787   return first;
1788 }
1789
1790   
1791 /* Read all pointer fields in the TS_COMMON structure of EXPR from input
1792    block IB.  DATA_IN contains tables and descriptors for the
1793    file being read.  */
1794
1795
1796 static void
1797 lto_input_ts_common_tree_pointers (struct lto_input_block *ib,
1798                                    struct data_in *data_in, tree expr)
1799 {
1800   TREE_TYPE (expr) = lto_input_tree (ib, data_in);
1801 }
1802
1803
1804 /* Read all pointer fields in the TS_VECTOR structure of EXPR from input
1805    block IB.  DATA_IN contains tables and descriptors for the
1806    file being read.  */
1807
1808 static void
1809 lto_input_ts_vector_tree_pointers (struct lto_input_block *ib,
1810                                    struct data_in *data_in, tree expr)
1811 {
1812   TREE_VECTOR_CST_ELTS (expr) = lto_input_chain (ib, data_in);
1813 }
1814
1815
1816 /* Read all pointer fields in the TS_COMPLEX structure of EXPR from input
1817    block IB.  DATA_IN contains tables and descriptors for the
1818    file being read.  */
1819
1820 static void
1821 lto_input_ts_complex_tree_pointers (struct lto_input_block *ib,
1822                                     struct data_in *data_in, tree expr)
1823 {
1824   TREE_REALPART (expr) = lto_input_tree (ib, data_in);
1825   TREE_IMAGPART (expr) = lto_input_tree (ib, data_in);
1826 }
1827
1828
1829 /* Read all pointer fields in the TS_DECL_MINIMAL structure of EXPR
1830    from input block IB.  DATA_IN contains tables and descriptors for the
1831    file being read.  */
1832
1833 static void
1834 lto_input_ts_decl_minimal_tree_pointers (struct lto_input_block *ib,
1835                                          struct data_in *data_in, tree expr)
1836 {
1837   DECL_NAME (expr) = lto_input_tree (ib, data_in);
1838   DECL_CONTEXT (expr) = lto_input_tree (ib, data_in);
1839   DECL_SOURCE_LOCATION (expr) = lto_input_location (ib, data_in);
1840 }
1841
1842
1843 /* Read all pointer fields in the TS_DECL_COMMON structure of EXPR from
1844    input block IB.  DATA_IN contains tables and descriptors for the
1845    file being read.  */
1846
1847 static void
1848 lto_input_ts_decl_common_tree_pointers (struct lto_input_block *ib,
1849                                         struct data_in *data_in, tree expr)
1850 {
1851   DECL_SIZE (expr) = lto_input_tree (ib, data_in);
1852   DECL_SIZE_UNIT (expr) = lto_input_tree (ib, data_in);
1853
1854   if (TREE_CODE (expr) != FUNCTION_DECL)
1855     DECL_INITIAL (expr) = lto_input_tree (ib, data_in);
1856
1857   DECL_ATTRIBUTES (expr) = lto_input_tree (ib, data_in);
1858   DECL_ABSTRACT_ORIGIN (expr) = lto_input_tree (ib, data_in);
1859
1860   if (TREE_CODE (expr) == PARM_DECL)
1861     TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
1862 }
1863
1864
1865 /* Read all pointer fields in the TS_DECL_NON_COMMON structure of
1866    EXPR from input block IB.  DATA_IN contains tables and descriptors for the
1867    file being read.  */
1868
1869 static void
1870 lto_input_ts_decl_non_common_tree_pointers (struct lto_input_block *ib,
1871                                             struct data_in *data_in, tree expr)
1872 {
1873   if (TREE_CODE (expr) == FUNCTION_DECL)
1874     {
1875       DECL_ARGUMENTS (expr) = lto_input_tree (ib, data_in);
1876       DECL_RESULT (expr) = lto_input_tree (ib, data_in);
1877     }
1878   DECL_VINDEX (expr) = lto_input_tree (ib, data_in);
1879 }
1880
1881
1882 /* Read all pointer fields in the TS_DECL_WITH_VIS structure of EXPR
1883    from input block IB.  DATA_IN contains tables and descriptors for the
1884    file being read.  */
1885
1886 static void
1887 lto_input_ts_decl_with_vis_tree_pointers (struct lto_input_block *ib,
1888                                           struct data_in *data_in, tree expr)
1889 {
1890   tree id;
1891   
1892   id = lto_input_tree (ib, data_in);
1893   if (id)
1894     {
1895       gcc_assert (TREE_CODE (id) == IDENTIFIER_NODE);
1896       SET_DECL_ASSEMBLER_NAME (expr, id);
1897     }
1898
1899   DECL_SECTION_NAME (expr) = lto_input_tree (ib, data_in);
1900   DECL_COMDAT_GROUP (expr) = lto_input_tree (ib, data_in);
1901 }
1902
1903
1904 /* Read all pointer fields in the TS_FIELD_DECL structure of EXPR from
1905    input block IB.  DATA_IN contains tables and descriptors for the
1906    file being read.  */
1907
1908 static void
1909 lto_input_ts_field_decl_tree_pointers (struct lto_input_block *ib,
1910                                        struct data_in *data_in, tree expr)
1911 {
1912   DECL_FIELD_OFFSET (expr) = lto_input_tree (ib, data_in);
1913   DECL_BIT_FIELD_TYPE (expr) = lto_input_tree (ib, data_in);
1914   DECL_QUALIFIER (expr) = lto_input_tree (ib, data_in);
1915   DECL_FIELD_BIT_OFFSET (expr) = lto_input_tree (ib, data_in);
1916   DECL_FCONTEXT (expr) = lto_input_tree (ib, data_in);
1917   TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
1918 }
1919
1920
1921 /* Read all pointer fields in the TS_FUNCTION_DECL structure of EXPR
1922    from input block IB.  DATA_IN contains tables and descriptors for the
1923    file being read.  */
1924
1925 static void
1926 lto_input_ts_function_decl_tree_pointers (struct lto_input_block *ib,
1927                                           struct data_in *data_in, tree expr)
1928 {
1929   /* DECL_STRUCT_FUNCTION is handled by lto_input_function.  FIXME lto,
1930      maybe it should be handled here?  */
1931   DECL_FUNCTION_PERSONALITY (expr) = lto_input_tree (ib, data_in);
1932   DECL_FUNCTION_SPECIFIC_TARGET (expr) = lto_input_tree (ib, data_in);
1933   DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr) = lto_input_tree (ib, data_in);
1934 }
1935
1936
1937 /* Read all pointer fields in the TS_TYPE structure of EXPR from input
1938    block IB.  DATA_IN contains tables and descriptors for the
1939    file being read.  */
1940
1941 static void
1942 lto_input_ts_type_tree_pointers (struct lto_input_block *ib,
1943                                  struct data_in *data_in, tree expr)
1944 {
1945   if (TREE_CODE (expr) == ENUMERAL_TYPE)
1946     TYPE_VALUES (expr) = lto_input_tree (ib, data_in);
1947   else if (TREE_CODE (expr) == ARRAY_TYPE)
1948     TYPE_DOMAIN (expr) = lto_input_tree (ib, data_in);
1949   else if (TREE_CODE (expr) == RECORD_TYPE || TREE_CODE (expr) == UNION_TYPE)
1950     TYPE_FIELDS (expr) = lto_input_tree (ib, data_in);
1951   else if (TREE_CODE (expr) == FUNCTION_TYPE || TREE_CODE (expr) == METHOD_TYPE)
1952     TYPE_ARG_TYPES (expr) = lto_input_tree (ib, data_in);
1953   else if (TREE_CODE (expr) == VECTOR_TYPE)
1954     TYPE_DEBUG_REPRESENTATION_TYPE (expr) = lto_input_tree (ib, data_in);
1955
1956   TYPE_SIZE (expr) = lto_input_tree (ib, data_in);
1957   TYPE_SIZE_UNIT (expr) = lto_input_tree (ib, data_in);
1958   TYPE_ATTRIBUTES (expr) = lto_input_tree (ib, data_in);
1959   TYPE_NAME (expr) = lto_input_tree (ib, data_in);
1960   /* Do not stream TYPE_POINTER_TO or TYPE_REFERENCE_TO nor
1961      TYPE_NEXT_PTR_TO or TYPE_NEXT_REF_TO.  */
1962   if (!POINTER_TYPE_P (expr))
1963     TYPE_MINVAL (expr) = lto_input_tree (ib, data_in);
1964   TYPE_MAXVAL (expr) = lto_input_tree (ib, data_in);
1965   TYPE_MAIN_VARIANT (expr) = lto_input_tree (ib, data_in);
1966   /* Do not stream TYPE_NEXT_VARIANT, we reconstruct the variant lists
1967      during fixup.  */
1968   if (RECORD_OR_UNION_TYPE_P (expr))
1969     TYPE_BINFO (expr) = lto_input_tree (ib, data_in);
1970   TYPE_CONTEXT (expr) = lto_input_tree (ib, data_in);
1971   TYPE_CANONICAL (expr) = lto_input_tree (ib, data_in);
1972 }
1973
1974
1975 /* Read all pointer fields in the TS_LIST structure of EXPR from input
1976    block IB.  DATA_IN contains tables and descriptors for the
1977    file being read.  */
1978
1979 static void
1980 lto_input_ts_list_tree_pointers (struct lto_input_block *ib,
1981                                  struct data_in *data_in, tree expr)
1982 {
1983   TREE_PURPOSE (expr) = lto_input_tree (ib, data_in);
1984   TREE_VALUE (expr) = lto_input_tree (ib, data_in);
1985   TREE_CHAIN (expr) = lto_input_chain (ib, data_in);
1986 }
1987
1988
1989 /* Read all pointer fields in the TS_VEC structure of EXPR from input
1990    block IB.  DATA_IN contains tables and descriptors for the
1991    file being read.  */
1992
1993 static void
1994 lto_input_ts_vec_tree_pointers (struct lto_input_block *ib,
1995                                 struct data_in *data_in, tree expr)
1996 {
1997   int i;
1998
1999   /* Note that TREE_VEC_LENGTH was read by lto_materialize_tree to
2000      instantiate EXPR.  */
2001   for (i = 0; i < TREE_VEC_LENGTH (expr); i++)
2002     TREE_VEC_ELT (expr, i) = lto_input_tree (ib, data_in);
2003 }
2004
2005
2006 /* Read all pointer fields in the TS_EXP structure of EXPR from input
2007    block IB.  DATA_IN contains tables and descriptors for the
2008    file being read.  */
2009
2010
2011 static void
2012 lto_input_ts_exp_tree_pointers (struct lto_input_block *ib,
2013                                 struct data_in *data_in, tree expr)
2014 {
2015   int i, length;
2016   location_t loc;
2017
2018   length = lto_input_sleb128 (ib);
2019   gcc_assert (length == TREE_OPERAND_LENGTH (expr));
2020
2021   for (i = 0; i < length; i++)
2022     TREE_OPERAND (expr, i) = lto_input_tree (ib, data_in);
2023
2024   loc = lto_input_location (ib, data_in);
2025   SET_EXPR_LOCATION (expr, loc);
2026   TREE_BLOCK (expr) = lto_input_tree (ib, data_in);
2027 }
2028
2029
2030 /* Read all pointer fields in the TS_BLOCK structure of EXPR from input
2031    block IB.  DATA_IN contains tables and descriptors for the
2032    file being read.  */
2033
2034 static void
2035 lto_input_ts_block_tree_pointers (struct lto_input_block *ib,
2036                                   struct data_in *data_in, tree expr)
2037 {
2038   unsigned i, len;
2039
2040   BLOCK_SOURCE_LOCATION (expr) = lto_input_location (ib, data_in);
2041   BLOCK_VARS (expr) = lto_input_chain (ib, data_in);
2042
2043   len = lto_input_uleb128 (ib);
2044   for (i = 0; i < len; i++)
2045     {
2046       tree t = lto_input_tree (ib, data_in);
2047       VEC_safe_push (tree, gc, BLOCK_NONLOCALIZED_VARS (expr), t);
2048     }
2049
2050   BLOCK_SUPERCONTEXT (expr) = lto_input_tree (ib, data_in);
2051   BLOCK_ABSTRACT_ORIGIN (expr) = lto_input_tree (ib, data_in);
2052   BLOCK_FRAGMENT_ORIGIN (expr) = lto_input_tree (ib, data_in);
2053   BLOCK_FRAGMENT_CHAIN (expr) = lto_input_tree (ib, data_in);
2054   BLOCK_SUBBLOCKS (expr) = lto_input_chain (ib, data_in);
2055 }
2056
2057
2058 /* Read all pointer fields in the TS_BINFO structure of EXPR from input
2059    block IB.  DATA_IN contains tables and descriptors for the
2060    file being read.  */
2061
2062 static void
2063 lto_input_ts_binfo_tree_pointers (struct lto_input_block *ib,
2064                                   struct data_in *data_in, tree expr)
2065 {
2066   unsigned i, len;
2067   tree t;
2068
2069   /* Note that the number of slots in EXPR was read in
2070      lto_materialize_tree when instantiating EXPR.  However, the
2071      vector is empty so we cannot rely on VEC_length to know how many
2072      elements to read.  So, this list is emitted as a 0-terminated
2073      list on the writer side.  */
2074   do
2075     {
2076       t = lto_input_tree (ib, data_in);
2077       if (t)
2078         VEC_quick_push (tree, BINFO_BASE_BINFOS (expr), t);
2079     }
2080   while (t);
2081
2082   BINFO_OFFSET (expr) = lto_input_tree (ib, data_in);
2083   BINFO_VTABLE (expr) = lto_input_tree (ib, data_in);
2084   BINFO_VIRTUALS (expr) = lto_input_tree (ib, data_in);
2085   BINFO_VPTR_FIELD (expr) = lto_input_tree (ib, data_in);
2086
2087   len = lto_input_uleb128 (ib);
2088   for (i = 0; i < len; i++)
2089     {
2090       tree a = lto_input_tree (ib, data_in);
2091       VEC_safe_push (tree, gc, BINFO_BASE_ACCESSES (expr), a);
2092     }
2093
2094   BINFO_INHERITANCE_CHAIN (expr) = lto_input_tree (ib, data_in);
2095   BINFO_SUBVTT_INDEX (expr) = lto_input_tree (ib, data_in);
2096   BINFO_VPTR_INDEX (expr) = lto_input_tree (ib, data_in);
2097 }
2098
2099
2100 /* Read all pointer fields in the TS_CONSTRUCTOR structure of EXPR from
2101    input block IB.  DATA_IN contains tables and descriptors for the
2102    file being read.  */
2103
2104 static void
2105 lto_input_ts_constructor_tree_pointers (struct lto_input_block *ib,
2106                                         struct data_in *data_in, tree expr)
2107 {
2108   unsigned i, len;
2109
2110   len = lto_input_uleb128 (ib);
2111   for (i = 0; i < len; i++)
2112     {
2113       tree index, value;
2114
2115       index = lto_input_tree (ib, data_in);
2116       value = lto_input_tree (ib, data_in);
2117       CONSTRUCTOR_APPEND_ELT (CONSTRUCTOR_ELTS (expr), index, value);
2118     }
2119 }
2120
2121
2122 /* Helper for lto_input_tree.  Read all pointer fields in EXPR from
2123    input block IB.  DATA_IN contains tables and descriptors for the
2124    file being read.  */
2125
2126 static void
2127 lto_input_tree_pointers (struct lto_input_block *ib, struct data_in *data_in,
2128                          tree expr)
2129 {
2130   enum tree_code code;
2131
2132   code = TREE_CODE (expr);
2133
2134   if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
2135     lto_input_ts_common_tree_pointers (ib, data_in, expr);
2136
2137   if (CODE_CONTAINS_STRUCT (code, TS_VECTOR))
2138     lto_input_ts_vector_tree_pointers (ib, data_in, expr);
2139
2140   if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX))
2141     lto_input_ts_complex_tree_pointers (ib, data_in, expr);
2142
2143   if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL))
2144     lto_input_ts_decl_minimal_tree_pointers (ib, data_in, expr);
2145
2146   if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
2147     lto_input_ts_decl_common_tree_pointers (ib, data_in, expr);
2148
2149   if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
2150     lto_input_ts_decl_non_common_tree_pointers (ib, data_in, expr);
2151
2152   if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
2153     lto_input_ts_decl_with_vis_tree_pointers (ib, data_in, expr);
2154
2155   if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
2156     lto_input_ts_field_decl_tree_pointers (ib, data_in, expr);
2157
2158   if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
2159     lto_input_ts_function_decl_tree_pointers (ib, data_in, expr);
2160
2161   if (CODE_CONTAINS_STRUCT (code, TS_TYPE))
2162     lto_input_ts_type_tree_pointers (ib, data_in, expr);
2163
2164   if (CODE_CONTAINS_STRUCT (code, TS_LIST))
2165     lto_input_ts_list_tree_pointers (ib, data_in, expr);
2166
2167   if (CODE_CONTAINS_STRUCT (code, TS_VEC))
2168     lto_input_ts_vec_tree_pointers (ib, data_in, expr);
2169
2170   if (CODE_CONTAINS_STRUCT (code, TS_EXP))
2171     lto_input_ts_exp_tree_pointers (ib, data_in, expr);
2172
2173   if (CODE_CONTAINS_STRUCT (code, TS_SSA_NAME))
2174     {
2175       /* We only stream the version number of SSA names.  */
2176       gcc_unreachable ();
2177     }
2178
2179   if (CODE_CONTAINS_STRUCT (code, TS_BLOCK))
2180     lto_input_ts_block_tree_pointers (ib, data_in, expr);
2181
2182   if (CODE_CONTAINS_STRUCT (code, TS_BINFO))
2183     lto_input_ts_binfo_tree_pointers (ib, data_in, expr);
2184
2185   if (CODE_CONTAINS_STRUCT (code, TS_STATEMENT_LIST))
2186     {
2187       /* This should only appear in GENERIC.  */
2188       gcc_unreachable ();
2189     }
2190
2191   if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR))
2192     lto_input_ts_constructor_tree_pointers (ib, data_in, expr);
2193
2194   if (CODE_CONTAINS_STRUCT (code, TS_OMP_CLAUSE))
2195     {
2196       /* This should only appear in High GIMPLE.  */
2197       gcc_unreachable ();
2198     }
2199
2200   if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION))
2201     {
2202       sorry ("optimization options not supported yet");
2203     }
2204
2205   if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION))
2206     {
2207       sorry ("target optimization options not supported yet");
2208     }
2209 }
2210
2211
2212 /* Register DECL with the global symbol table and change its
2213    name if necessary to avoid name clashes for static globals across
2214    different files.  */
2215
2216 static void
2217 lto_register_var_decl_in_symtab (struct data_in *data_in, tree decl)
2218 {
2219   /* Register symbols with file or global scope to mark what input
2220      file has their definition.  */
2221   if (decl_function_context (decl) == NULL_TREE)
2222     {
2223       /* Variable has file scope, not local. Need to ensure static variables
2224          between different files don't clash unexpectedly.  */
2225       if (!TREE_PUBLIC (decl))
2226         {
2227           /* ??? We normally pre-mangle names before we serialize them
2228              out.  Here, in lto1, we do not know the language, and
2229              thus cannot do the mangling again. Instead, we just
2230              append a suffix to the mangled name.  The resulting name,
2231              however, is not a properly-formed mangled name, and will
2232              confuse any attempt to unmangle it.  */
2233           const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2234           char *label;
2235       
2236           ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
2237           SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
2238           rest_of_decl_compilation (decl, 1, 0);
2239         }
2240     }
2241
2242   /* If this variable has already been declared, queue the
2243      declaration for merging.  */
2244   if (TREE_PUBLIC (decl))
2245     {
2246       int ix;
2247       if (!lto_streamer_cache_lookup (data_in->reader_cache, decl, &ix))
2248         gcc_unreachable ();
2249       lto_symtab_register_decl (decl, get_resolution (data_in, ix),
2250                                 data_in->file_data);
2251     }
2252 }
2253
2254
2255
2256 /* Register DECL with the global symbol table and change its
2257    name if necessary to avoid name clashes for static globals across
2258    different files.  DATA_IN contains descriptors and tables for the
2259    file being read.  */
2260
2261 static void
2262 lto_register_function_decl_in_symtab (struct data_in *data_in, tree decl)
2263 {
2264   /* Need to ensure static entities between different files
2265      don't clash unexpectedly.  */
2266   if (!TREE_PUBLIC (decl))
2267     {
2268       /* We must not use the DECL_ASSEMBLER_NAME macro here, as it
2269          may set the assembler name where it was previously empty.  */
2270       tree old_assembler_name = decl->decl_with_vis.assembler_name;
2271
2272       /* FIXME lto: We normally pre-mangle names before we serialize
2273          them out.  Here, in lto1, we do not know the language, and
2274          thus cannot do the mangling again. Instead, we just append a
2275          suffix to the mangled name.  The resulting name, however, is
2276          not a properly-formed mangled name, and will confuse any
2277          attempt to unmangle it.  */
2278       const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2279       char *label;
2280       
2281       ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
2282       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
2283
2284       /* We may arrive here with the old assembler name not set
2285          if the function body is not needed, e.g., it has been
2286          inlined away and does not appear in the cgraph.  */
2287       if (old_assembler_name)
2288         {
2289           tree new_assembler_name = DECL_ASSEMBLER_NAME (decl);
2290
2291           /* Make the original assembler name available for later use.
2292              We may have used it to indicate the section within its
2293              object file where the function body may be found.
2294              FIXME lto: Find a better way to maintain the function decl
2295              to body section mapping so we don't need this hack.  */
2296           lto_record_renamed_decl (data_in->file_data,
2297                                    IDENTIFIER_POINTER (old_assembler_name),
2298                                    IDENTIFIER_POINTER (new_assembler_name));
2299
2300           /* Also register the reverse mapping so that we can find the
2301              new name given to an existing assembler name (used when
2302              restoring alias pairs in input_constructors_or_inits.  */ 
2303           lto_record_renamed_decl (data_in->file_data,
2304                                    IDENTIFIER_POINTER (new_assembler_name),
2305                                    IDENTIFIER_POINTER (old_assembler_name));
2306         }                                  
2307     }
2308
2309   /* If this variable has already been declared, queue the
2310      declaration for merging.  */
2311   if (TREE_PUBLIC (decl) && !DECL_ABSTRACT (decl))
2312     {
2313       int ix;
2314       if (!lto_streamer_cache_lookup (data_in->reader_cache, decl, &ix))
2315         gcc_unreachable ();
2316       lto_symtab_register_decl (decl, get_resolution (data_in, ix),
2317                                 data_in->file_data);
2318     }
2319 }
2320
2321
2322 /* Read an index IX from input block IB and return the tree node at
2323    DATA_IN->FILE_DATA->GLOBALS_INDEX[IX].  */
2324
2325 static tree
2326 lto_get_pickled_tree (struct lto_input_block *ib, struct data_in *data_in)
2327 {
2328   HOST_WIDE_INT ix;
2329   tree result;
2330   enum LTO_tags expected_tag;
2331   unsigned HOST_WIDE_INT orig_offset;
2332
2333   ix = lto_input_sleb128 (ib);
2334   expected_tag = (enum LTO_tags) lto_input_uleb128 (ib);
2335
2336   orig_offset = lto_input_uleb128 (ib);
2337   gcc_assert (orig_offset == (unsigned) orig_offset);
2338
2339   result = lto_streamer_cache_get (data_in->reader_cache, ix);
2340   if (result == NULL_TREE)
2341     {
2342       /* We have not yet read the cache slot IX.  Go to the offset
2343          in the stream where the physical tree node is, and materialize
2344          it from there.  */
2345       struct lto_input_block fwd_ib;
2346
2347       /* If we are trying to go back in the stream, something is wrong.
2348          We should've read the node at the earlier position already.  */
2349       if (ib->p >= orig_offset)
2350         internal_error ("bytecode stream: tried to jump backwards in the "
2351                         "stream");
2352
2353       LTO_INIT_INPUT_BLOCK (fwd_ib, ib->data, orig_offset, ib->len);
2354       result = lto_input_tree (&fwd_ib, data_in);
2355     }
2356
2357   gcc_assert (result
2358               && TREE_CODE (result) == lto_tag_to_tree_code (expected_tag));
2359
2360   return result;
2361 }
2362
2363
2364 /* Read a code and class from input block IB and return the
2365    corresponding builtin.  DATA_IN is as in lto_input_tree.  */
2366
2367 static tree
2368 lto_get_builtin_tree (struct lto_input_block *ib, struct data_in *data_in)
2369 {
2370   enum built_in_class fclass;
2371   enum built_in_function fcode;
2372   const char *asmname;
2373   tree result;
2374   int ix;
2375
2376   fclass = (enum built_in_class) lto_input_uleb128 (ib);
2377   gcc_assert (fclass == BUILT_IN_NORMAL || fclass == BUILT_IN_MD);
2378
2379   fcode = (enum built_in_function) lto_input_uleb128 (ib);
2380
2381   ix = lto_input_sleb128 (ib);
2382   gcc_assert (ix == (int) ix);
2383
2384   if (fclass == BUILT_IN_NORMAL)
2385     {
2386       gcc_assert (fcode < END_BUILTINS);
2387       result = built_in_decls[fcode];
2388       gcc_assert (result);
2389     }
2390   else if (fclass == BUILT_IN_MD)
2391     {
2392       result = targetm.builtin_decl (fcode, true);
2393       if (!result || result == error_mark_node)
2394         fatal_error ("target specific builtin not available");
2395     }
2396
2397   asmname = input_string (data_in, ib);
2398   if (asmname)
2399     set_builtin_user_assembler_name (result, asmname);
2400
2401   lto_streamer_cache_insert_at (data_in->reader_cache, result, ix);
2402
2403   return result;
2404 }
2405
2406
2407 /* Read the physical representation of a tree node with tag TAG from
2408    input block IB using the per-file context in DATA_IN.  */
2409
2410 static tree
2411 lto_read_tree (struct lto_input_block *ib, struct data_in *data_in,
2412                enum LTO_tags tag)
2413 {
2414   tree result;
2415   char end_marker;
2416   int ix;
2417
2418   result = lto_materialize_tree (ib, data_in, tag, &ix);
2419
2420   /* Read all the pointer fields in RESULT.  */
2421   lto_input_tree_pointers (ib, data_in, result);
2422
2423   /* We should never try to instantiate an MD or NORMAL builtin here.  */
2424   if (TREE_CODE (result) == FUNCTION_DECL)
2425     gcc_assert (!lto_stream_as_builtin_p (result));
2426
2427   if (TREE_CODE (result) == VAR_DECL)
2428     lto_register_var_decl_in_symtab (data_in, result);
2429   else if (TREE_CODE (result) == FUNCTION_DECL && !DECL_BUILT_IN (result))
2430     lto_register_function_decl_in_symtab (data_in, result);
2431
2432   end_marker = lto_input_1_unsigned (ib);
2433
2434 #ifdef LTO_STREAMER_DEBUG
2435   /* Remove the mapping to RESULT's original address set by
2436      lto_materialize_tree.  */
2437   lto_orig_address_remove (result);
2438 #endif
2439
2440   return result;
2441 }
2442
2443
2444 /* Read and INTEGER_CST node from input block IB using the per-file
2445    context in DATA_IN.  */
2446
2447 static tree
2448 lto_input_integer_cst (struct lto_input_block *ib, struct data_in *data_in)
2449 {
2450   tree result, type;
2451   HOST_WIDE_INT low, high;
2452   bool overflow_p;
2453
2454   type = lto_input_tree (ib, data_in);
2455   overflow_p = (lto_input_1_unsigned (ib) != 0);
2456   low = lto_input_uleb128 (ib);
2457   high = lto_input_uleb128 (ib);
2458   result = build_int_cst_wide (type, low, high);
2459
2460   /* If the original constant had overflown, build a replica of RESULT to
2461      avoid modifying the shared constant returned by build_int_cst_wide.  */
2462   if (overflow_p)
2463     {
2464       result = copy_node (result);
2465       TREE_OVERFLOW (result) = 1;
2466     }
2467
2468   return result;
2469 }
2470
2471
2472 /* Read a tree from input block IB using the per-file context in
2473    DATA_IN.  This context is used, for example, to resolve references
2474    to previously read nodes.  */
2475
2476 tree
2477 lto_input_tree (struct lto_input_block *ib, struct data_in *data_in)
2478 {
2479   enum LTO_tags tag;
2480   tree result;
2481   
2482   tag = input_record_start (ib);
2483   gcc_assert ((unsigned) tag < (unsigned) LTO_NUM_TAGS);
2484
2485   if (tag == LTO_null)
2486     result = NULL_TREE;
2487   else if (tag >= LTO_field_decl_ref && tag <= LTO_global_decl_ref)
2488     {
2489       /* If TAG is a reference to an indexable tree, the next value
2490          in IB is the index into the table where we expect to find
2491          that tree.  */
2492       result = lto_input_tree_ref (ib, data_in, cfun, tag);
2493     }
2494   else if (tag == LTO_tree_pickle_reference)
2495     {
2496       /* If TAG is a reference to a previously read tree, look it up in
2497          the reader cache.  */
2498       result = lto_get_pickled_tree (ib, data_in);
2499     }
2500   else if (tag == LTO_builtin_decl)
2501     {
2502       /* If we are going to read a built-in function, all we need is
2503          the code and class.  */
2504       result = lto_get_builtin_tree (ib, data_in);
2505     }
2506   else if (tag == lto_tree_code_to_tag (INTEGER_CST))
2507     {
2508       /* For integer constants we only need the type and its hi/low
2509          words.  */
2510       result = lto_input_integer_cst (ib, data_in);
2511     }
2512   else
2513     {
2514       /* Otherwise, materialize a new node from IB.  */
2515       result = lto_read_tree (ib, data_in, tag);
2516     }
2517
2518   return result;
2519 }
2520
2521
2522 /* Initialization for the LTO reader.  */
2523
2524 void
2525 lto_init_reader (void)
2526 {
2527   lto_streamer_init ();
2528
2529   memset (&lto_stats, 0, sizeof (lto_stats));
2530   bitmap_obstack_initialize (NULL);
2531
2532   file_name_hash_table = htab_create (37, hash_string_slot_node,
2533                                       eq_string_slot_node, free);
2534
2535   gimple_register_cfg_hooks ();
2536 }
2537
2538
2539 /* Create a new data_in object for FILE_DATA. STRINGS is the string
2540    table to use with LEN strings.  RESOLUTIONS is the vector of linker
2541    resolutions (NULL if not using a linker plugin).  */
2542
2543 struct data_in *
2544 lto_data_in_create (struct lto_file_decl_data *file_data, const char *strings,
2545                     unsigned len,
2546                     VEC(ld_plugin_symbol_resolution_t,heap) *resolutions)
2547 {
2548   struct data_in *data_in = XCNEW (struct data_in);
2549   data_in->file_data = file_data;
2550   data_in->strings = strings;
2551   data_in->strings_len = len;
2552   data_in->globals_resolution = resolutions;
2553   data_in->reader_cache = lto_streamer_cache_create ();
2554
2555   return data_in;
2556 }
2557
2558
2559 /* Remove DATA_IN.  */
2560
2561 void
2562 lto_data_in_delete (struct data_in *data_in)
2563 {
2564   VEC_free (ld_plugin_symbol_resolution_t, heap, data_in->globals_resolution);
2565   lto_streamer_cache_delete (data_in->reader_cache);
2566   free (data_in->labels);
2567   free (data_in);
2568 }