OSDN Git Service

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