OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [lto-streamer-in.c] - Blame information for rev 280

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.