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/] [lto.c] - Blame information for rev 304

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 288 jeremybenn
/* Top-level LTO routines.
2
   Copyright 2009, 2010 Free Software Foundation, Inc.
3
   Contributed by CodeSourcery, Inc.
4
 
5
This file is part of GCC.
6
 
7
GCC is free software; you can redistribute it and/or modify it under
8
the terms of the GNU General Public License as published by the Free
9
Software Foundation; either version 3, or (at your option) any later
10
version.
11
 
12
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13
WARRANTY; without even the implied warranty of MERCHANTABILITY or
14
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15
for more details.
16
 
17
You should have received a copy of the GNU General Public License
18
along with GCC; see the file COPYING3.  If not see
19
<http://www.gnu.org/licenses/>.  */
20
 
21
#include "config.h"
22
#include "system.h"
23
#include "coretypes.h"
24
#include "opts.h"
25
#include "toplev.h"
26
#include "tree.h"
27
#include "diagnostic.h"
28
#include "tm.h"
29
#include "libiberty.h"
30
#include "cgraph.h"
31
#include "ggc.h"
32
#include "tree-ssa-operands.h"
33
#include "tree-pass.h"
34
#include "langhooks.h"
35
#include "vec.h"
36
#include "bitmap.h"
37
#include "pointer-set.h"
38
#include "ipa-prop.h"
39
#include "common.h"
40
#include "timevar.h"
41
#include "gimple.h"
42
#include "lto.h"
43
#include "lto-tree.h"
44
#include "lto-streamer.h"
45
 
46
/* This needs to be included after config.h.  Otherwise, _GNU_SOURCE will not
47
   be defined in time to set __USE_GNU in the system headers, and strsignal
48
   will not be declared.  */
49
#if HAVE_MMAP_FILE
50
#include <sys/mman.h>
51
#endif
52
 
53
/* Handle opening elf files on hosts, such as Windows, that may use
54
   text file handling that will break binary access.  */
55
 
56
#ifndef O_BINARY
57
# define O_BINARY 0
58
#endif
59
 
60
 
61
DEF_VEC_P(bitmap);
62
DEF_VEC_ALLOC_P(bitmap,heap);
63
 
64
/* Read the constructors and inits.  */
65
 
66
static void
67
lto_materialize_constructors_and_inits (struct lto_file_decl_data * file_data)
68
{
69
  size_t len;
70
  const char *data = lto_get_section_data (file_data,
71
                                           LTO_section_static_initializer,
72
                                           NULL, &len);
73
  lto_input_constructors_and_inits (file_data, data);
74
  lto_free_section_data (file_data, LTO_section_static_initializer, NULL,
75
                         data, len);
76
}
77
 
78
/* Read the function body for the function associated with NODE if possible.  */
79
 
80
static void
81
lto_materialize_function (struct cgraph_node *node)
82
{
83
  tree decl;
84
  struct lto_file_decl_data *file_data;
85
  const char *data, *name;
86
  size_t len;
87
  tree step;
88
 
89
  /* Ignore clone nodes.  Read the body only from the original one.
90
     We may find clone nodes during LTRANS after WPA has made inlining
91
     decisions.  */
92
  if (node->clone_of)
93
    return;
94
 
95
  decl = node->decl;
96
  file_data = node->local.lto_file_data;
97
  name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
98
 
99
  /* We may have renamed the declaration, e.g., a static function.  */
100
  name = lto_get_decl_name_mapping (file_data, name);
101
 
102
  data = lto_get_section_data (file_data, LTO_section_function_body,
103
                               name, &len);
104
  if (data)
105
    {
106
      struct function *fn;
107
 
108
      gcc_assert (!DECL_IS_BUILTIN (decl));
109
 
110
      /* This function has a definition.  */
111
      TREE_STATIC (decl) = 1;
112
 
113
      gcc_assert (DECL_STRUCT_FUNCTION (decl) == NULL);
114
      allocate_struct_function (decl, false);
115
 
116
      /* Load the function body only if not operating in WPA mode.  In
117
         WPA mode, the body of the function is not needed.  */
118
      if (!flag_wpa)
119
        {
120
          lto_input_function_body (file_data, decl, data);
121
          lto_stats.num_function_bodies++;
122
        }
123
 
124
      fn = DECL_STRUCT_FUNCTION (decl);
125
      lto_free_section_data (file_data, LTO_section_function_body, name,
126
                             data, len);
127
 
128
      /* Look for initializers of constant variables and private
129
         statics.  */
130
      for (step = fn->local_decls; step; step = TREE_CHAIN (step))
131
        {
132
          tree decl = TREE_VALUE (step);
133
          if (TREE_CODE (decl) == VAR_DECL
134
              && (TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
135
              && flag_unit_at_a_time)
136
            varpool_finalize_decl (decl);
137
        }
138
    }
139
  else
140
    DECL_EXTERNAL (decl) = 1;
141
 
142
  /* Let the middle end know about the function.  */
143
  rest_of_decl_compilation (decl, 1, 0);
144
  if (cgraph_node (decl)->needed)
145
    cgraph_mark_reachable_node (cgraph_node (decl));
146
}
147
 
148
 
149
/* Decode the content of memory pointed to by DATA in the the
150
   in decl state object STATE. DATA_IN points to a data_in structure for
151
   decoding. Return the address after the decoded object in the input.  */
152
 
153
static const uint32_t *
154
lto_read_in_decl_state (struct data_in *data_in, const uint32_t *data,
155
                        struct lto_in_decl_state *state)
156
{
157
  uint32_t ix;
158
  tree decl;
159
  uint32_t i, j;
160
 
161
  ix = *data++;
162
  decl = lto_streamer_cache_get (data_in->reader_cache, (int) ix);
163
  if (TREE_CODE (decl) != FUNCTION_DECL)
164
    {
165
      gcc_assert (decl == void_type_node);
166
      decl = NULL_TREE;
167
    }
168
  state->fn_decl = decl;
169
 
170
  for (i = 0; i < LTO_N_DECL_STREAMS; i++)
171
    {
172
      uint32_t size = *data++;
173
      tree *decls = (tree *) xcalloc (size, sizeof (tree));
174
 
175
      for (j = 0; j < size; j++)
176
        {
177
          decls[j] = lto_streamer_cache_get (data_in->reader_cache, data[j]);
178
 
179
          /* Register every type in the global type table.  If the
180
             type existed already, use the existing type.  */
181
          if (TYPE_P (decls[j]))
182
            decls[j] = gimple_register_type (decls[j]);
183
        }
184
 
185
      state->streams[i].size = size;
186
      state->streams[i].trees = decls;
187
      data += size;
188
    }
189
 
190
  return data;
191
}
192
 
193
 
194
/* Read all the symbols from buffer DATA, using descriptors in DECL_DATA.
195
   RESOLUTIONS is the set of symbols picked by the linker (read from the
196
   resolution file when the linker plugin is being used).  */
197
 
198
static void
199
lto_read_decls (struct lto_file_decl_data *decl_data, const void *data,
200
                VEC(ld_plugin_symbol_resolution_t,heap) *resolutions)
201
{
202
  const struct lto_decl_header *header = (const struct lto_decl_header *) data;
203
  const int32_t decl_offset = sizeof (struct lto_decl_header);
204
  const int32_t main_offset = decl_offset + header->decl_state_size;
205
  const int32_t string_offset = main_offset + header->main_size;
206
  struct lto_input_block ib_main;
207
  struct data_in *data_in;
208
  unsigned int i;
209
  const uint32_t *data_ptr, *data_end;
210
  uint32_t num_decl_states;
211
 
212
  LTO_INIT_INPUT_BLOCK (ib_main, (const char *) data + main_offset, 0,
213
                        header->main_size);
214
 
215
  data_in = lto_data_in_create (decl_data, (const char *) data + string_offset,
216
                                header->string_size, resolutions);
217
 
218
  /* Read the global declarations and types.  */
219
  while (ib_main.p < ib_main.len)
220
    {
221
      tree t = lto_input_tree (&ib_main, data_in);
222
      gcc_assert (t && ib_main.p <= ib_main.len);
223
    }
224
 
225
  /* Read in lto_in_decl_state objects.  */
226
  data_ptr = (const uint32_t *) ((const char*) data + decl_offset);
227
  data_end =
228
     (const uint32_t *) ((const char*) data_ptr + header->decl_state_size);
229
  num_decl_states = *data_ptr++;
230
 
231
  gcc_assert (num_decl_states > 0);
232
  decl_data->global_decl_state = lto_new_in_decl_state ();
233
  data_ptr = lto_read_in_decl_state (data_in, data_ptr,
234
                                     decl_data->global_decl_state);
235
 
236
  /* Read in per-function decl states and enter them in hash table.  */
237
  decl_data->function_decl_states =
238
    htab_create (37, lto_hash_in_decl_state, lto_eq_in_decl_state, free);
239
 
240
  for (i = 1; i < num_decl_states; i++)
241
    {
242
      struct lto_in_decl_state *state = lto_new_in_decl_state ();
243
      void **slot;
244
 
245
      data_ptr = lto_read_in_decl_state (data_in, data_ptr, state);
246
      slot = htab_find_slot (decl_data->function_decl_states, state, INSERT);
247
      gcc_assert (*slot == NULL);
248
      *slot = state;
249
    }
250
 
251
  if (data_ptr != data_end)
252
    internal_error ("bytecode stream: garbage at the end of symbols section");
253
 
254
  /* Set the current decl state to be the global state. */
255
  decl_data->current_decl_state = decl_data->global_decl_state;
256
 
257
  lto_data_in_delete (data_in);
258
}
259
 
260
/* strtoll is not portable. */
261
int64_t
262
lto_parse_hex (const char *p) {
263
  uint64_t ret = 0;
264
  for (; *p != '\0'; ++p)
265
    {
266
      char c = *p;
267
      unsigned char part;
268
      ret <<= 4;
269
      if (c >= '0' && c <= '9')
270
        part = c - '0';
271
      else if (c >= 'a' && c <= 'f')
272
        part = c - 'a' + 10;
273
      else if (c >= 'A' && c <= 'F')
274
        part = c - 'A' + 10;
275
      else
276
        internal_error ("could not parse hex number");
277
      ret |= part;
278
    }
279
  return ret;
280
}
281
 
282
/* Read resolution for file named FILE_NAME. The resolution is read from
283
   RESOLUTION. An array with the symbol resolution is returned. The array
284
   size is written to SIZE. */
285
 
286
static VEC(ld_plugin_symbol_resolution_t,heap) *
287
lto_resolution_read (FILE *resolution, lto_file *file)
288
{
289
  /* We require that objects in the resolution file are in the same
290
     order as the lto1 command line. */
291
  unsigned int name_len;
292
  char *obj_name;
293
  unsigned int num_symbols;
294
  unsigned int i;
295
  VEC(ld_plugin_symbol_resolution_t,heap) *ret = NULL;
296
  unsigned max_index = 0;
297
 
298
  if (!resolution)
299
    return NULL;
300
 
301
  name_len = strlen (file->filename);
302
  obj_name = XNEWVEC (char, name_len + 1);
303
  fscanf (resolution, " ");   /* Read white space. */
304
 
305
  fread (obj_name, sizeof (char), name_len, resolution);
306
  obj_name[name_len] = '\0';
307
  if (strcmp (obj_name, file->filename) != 0)
308
    internal_error ("unexpected file name %s in linker resolution file. "
309
                    "Expected %s", obj_name, file->filename);
310
  if (file->offset != 0)
311
    {
312
      int t;
313
      char offset_p[17];
314
      int64_t offset;
315
      t = fscanf (resolution, "@0x%16s", offset_p);
316
      if (t != 1)
317
        internal_error ("could not parse file offset");
318
      offset = lto_parse_hex (offset_p);
319
      if (offset != file->offset)
320
        internal_error ("unexpected offset");
321
    }
322
 
323
  free (obj_name);
324
 
325
  fscanf (resolution, "%u", &num_symbols);
326
 
327
  for (i = 0; i < num_symbols; i++)
328
    {
329
      int t;
330
      unsigned index;
331
      char r_str[27];
332
      enum ld_plugin_symbol_resolution r;
333
      unsigned int j;
334
      unsigned int lto_resolution_str_len =
335
        sizeof (lto_resolution_str) / sizeof (char *);
336
 
337
      t = fscanf (resolution, "%u %26s %*[^\n]\n", &index, r_str);
338
      if (t != 2)
339
        internal_error ("Invalid line in the resolution file.");
340
      if (index > max_index)
341
        max_index = index;
342
 
343
      for (j = 0; j < lto_resolution_str_len; j++)
344
        {
345
          if (strcmp (lto_resolution_str[j], r_str) == 0)
346
            {
347
              r = (enum ld_plugin_symbol_resolution) j;
348
              break;
349
            }
350
        }
351
      if (j == lto_resolution_str_len)
352
        internal_error ("Invalid resolution in the resolution file.");
353
 
354
      VEC_safe_grow_cleared (ld_plugin_symbol_resolution_t, heap, ret,
355
                             max_index + 1);
356
      VEC_replace (ld_plugin_symbol_resolution_t, ret, index, r);
357
    }
358
 
359
  return ret;
360
}
361
 
362
/* Generate a TREE representation for all types and external decls
363
   entities in FILE.
364
 
365
   Read all of the globals out of the file.  Then read the cgraph
366
   and process the .o index into the cgraph nodes so that it can open
367
   the .o file to load the functions and ipa information.   */
368
 
369
static struct lto_file_decl_data *
370
lto_file_read (lto_file *file, FILE *resolution_file)
371
{
372
  struct lto_file_decl_data *file_data;
373
  const char *data;
374
  size_t len;
375
  VEC(ld_plugin_symbol_resolution_t,heap) *resolutions;
376
 
377
  resolutions = lto_resolution_read (resolution_file, file);
378
 
379
  file_data = XCNEW (struct lto_file_decl_data);
380
  file_data->file_name = file->filename;
381
  file_data->section_hash_table = lto_obj_build_section_table (file);
382
  file_data->renaming_hash_table = lto_create_renaming_table ();
383
 
384
  data = lto_get_section_data (file_data, LTO_section_decls, NULL, &len);
385
  lto_read_decls (file_data, data, resolutions);
386
  lto_free_section_data (file_data, LTO_section_decls, NULL, data, len);
387
 
388
  return file_data;
389
}
390
 
391
#if HAVE_MMAP_FILE && HAVE_SYSCONF && defined _SC_PAGE_SIZE
392
#define LTO_MMAP_IO 1
393
#endif
394
 
395
#if LTO_MMAP_IO
396
/* Page size of machine is used for mmap and munmap calls.  */
397
static size_t page_mask;
398
#endif
399
 
400
/* Get the section data of length LEN from FILENAME starting at
401
   OFFSET.  The data segment must be freed by the caller when the
402
   caller is finished.  Returns NULL if all was not well.  */
403
 
404
static char *
405
lto_read_section_data (struct lto_file_decl_data *file_data,
406
                       intptr_t offset, size_t len)
407
{
408
  char *result;
409
  static int fd = -1;
410
  static char *fd_name;
411
#if LTO_MMAP_IO
412
  intptr_t computed_len;
413
  intptr_t computed_offset;
414
  intptr_t diff;
415
#endif
416
 
417
  /* Keep a single-entry file-descriptor cache.  The last file we
418
     touched will get closed at exit.
419
     ???  Eventually we want to add a more sophisticated larger cache
420
     or rather fix function body streaming to not stream them in
421
     practically random order.  */
422
  if (fd != -1
423
      && strcmp (fd_name, file_data->file_name) != 0)
424
    {
425
      free (fd_name);
426
      close (fd);
427
      fd = -1;
428
    }
429
  if (fd == -1)
430
    {
431
      fd_name = xstrdup (file_data->file_name);
432
      fd = open (file_data->file_name, O_RDONLY|O_BINARY);
433
      if (fd == -1)
434
        return NULL;
435
    }
436
 
437
#if LTO_MMAP_IO
438
  if (!page_mask)
439
    {
440
      size_t page_size = sysconf (_SC_PAGE_SIZE);
441
      page_mask = ~(page_size - 1);
442
    }
443
 
444
  computed_offset = offset & page_mask;
445
  diff = offset - computed_offset;
446
  computed_len = len + diff;
447
 
448
  result = (char *) mmap (NULL, computed_len, PROT_READ, MAP_PRIVATE,
449
                          fd, computed_offset);
450
  if (result == MAP_FAILED)
451
    return NULL;
452
 
453
  return result + diff;
454
#else
455
  result = (char *) xmalloc (len);
456
  if (lseek (fd, offset, SEEK_SET) != offset
457
      || read (fd, result, len) != (ssize_t) len)
458
    {
459
      free (result);
460
      return NULL;
461
    }
462
 
463
  return result;
464
#endif
465
}
466
 
467
 
468
/* Get the section data from FILE_DATA of SECTION_TYPE with NAME.
469
   NAME will be NULL unless the section type is for a function
470
   body.  */
471
 
472
static const char *
473
get_section_data (struct lto_file_decl_data *file_data,
474
                      enum lto_section_type section_type,
475
                      const char *name,
476
                      size_t *len)
477
{
478
  htab_t section_hash_table = file_data->section_hash_table;
479
  struct lto_section_slot *f_slot;
480
  struct lto_section_slot s_slot;
481
  const char *section_name = lto_get_section_name (section_type, name);
482
  char *data = NULL;
483
 
484
  *len = 0;
485
  s_slot.name = section_name;
486
  f_slot = (struct lto_section_slot *) htab_find (section_hash_table, &s_slot);
487
  if (f_slot)
488
    {
489
      data = lto_read_section_data (file_data, f_slot->start, f_slot->len);
490
      *len = f_slot->len;
491
    }
492
 
493
  free (CONST_CAST (char *, section_name));
494
  return data;
495
}
496
 
497
 
498
/* Free the section data from FILE_DATA of SECTION_TYPE with NAME that
499
   starts at OFFSET and has LEN bytes.  */
500
 
501
static void
502
free_section_data (struct lto_file_decl_data *file_data ATTRIBUTE_UNUSED,
503
                   enum lto_section_type section_type ATTRIBUTE_UNUSED,
504
                   const char *name ATTRIBUTE_UNUSED,
505
                   const char *offset, size_t len ATTRIBUTE_UNUSED)
506
{
507
#if LTO_MMAP_IO
508
  intptr_t computed_len;
509
  intptr_t computed_offset;
510
  intptr_t diff;
511
#endif
512
 
513
#if LTO_MMAP_IO
514
  computed_offset = ((intptr_t) offset) & page_mask;
515
  diff = (intptr_t) offset - computed_offset;
516
  computed_len = len + diff;
517
 
518
  munmap ((caddr_t) computed_offset, computed_len);
519
#else
520
  free (CONST_CAST(char *, offset));
521
#endif
522
}
523
 
524
/* Vector of all cgraph node sets. */
525
static GTY (()) VEC(cgraph_node_set, gc) *lto_cgraph_node_sets;
526
 
527
 
528
/* Group cgrah nodes by input files.  This is used mainly for testing
529
   right now.  */
530
 
531
static void
532
lto_1_to_1_map (void)
533
{
534
  struct cgraph_node *node;
535
  struct lto_file_decl_data *file_data;
536
  struct pointer_map_t *pmap;
537
  cgraph_node_set set;
538
  void **slot;
539
 
540
  timevar_push (TV_WHOPR_WPA);
541
 
542
  lto_cgraph_node_sets = VEC_alloc (cgraph_node_set, gc, 1);
543
 
544
  /* If the cgraph is empty, create one cgraph node set so that there is still
545
     an output file for any variables that need to be exported in a DSO.  */
546
  if (!cgraph_nodes)
547
    {
548
      set = cgraph_node_set_new ();
549
      VEC_safe_push (cgraph_node_set, gc, lto_cgraph_node_sets, set);
550
      goto finish;
551
    }
552
 
553
  pmap = pointer_map_create ();
554
 
555
  for (node = cgraph_nodes; node; node = node->next)
556
    {
557
      /* We only need to partition the nodes that we read from the
558
         gimple bytecode files.  */
559
      file_data = node->local.lto_file_data;
560
      if (file_data == NULL)
561
        continue;
562
 
563
      slot = pointer_map_contains (pmap, file_data);
564
      if (slot)
565
        set = (cgraph_node_set) *slot;
566
      else
567
        {
568
          set = cgraph_node_set_new ();
569
          slot = pointer_map_insert (pmap, file_data);
570
          *slot = set;
571
          VEC_safe_push (cgraph_node_set, gc, lto_cgraph_node_sets, set);
572
        }
573
 
574
      cgraph_node_set_add (set, node);
575
    }
576
 
577
  pointer_map_destroy (pmap);
578
 
579
finish:
580
  timevar_pop (TV_WHOPR_WPA);
581
 
582
  lto_stats.num_cgraph_partitions += VEC_length (cgraph_node_set,
583
                                                 lto_cgraph_node_sets);
584
}
585
 
586
 
587
/* Add inlined clone NODE and its master clone to SET, if NODE itself has
588
   inlined callees, recursively add the callees.  */
589
 
590
static void
591
lto_add_inline_clones (cgraph_node_set set, struct cgraph_node *node,
592
                       bitmap original_decls, bitmap inlined_decls)
593
{
594
   struct cgraph_node *callee;
595
   struct cgraph_edge *edge;
596
 
597
   cgraph_node_set_add (set, node);
598
 
599
   if (!bitmap_bit_p (original_decls, DECL_UID (node->decl)))
600
     bitmap_set_bit (inlined_decls, DECL_UID (node->decl));
601
 
602
   /* Check to see if NODE has any inlined callee.  */
603
   for (edge = node->callees; edge != NULL; edge = edge->next_callee)
604
     {
605
        callee = edge->callee;
606
        if (callee->global.inlined_to != NULL)
607
          lto_add_inline_clones (set, callee, original_decls, inlined_decls);
608
     }
609
}
610
 
611
/* Compute the transitive closure of inlining of SET based on the
612
   information in the callgraph.  Returns a bitmap of decls that have
613
   been inlined into SET indexed by UID.  */
614
 
615
static bitmap
616
lto_add_all_inlinees (cgraph_node_set set)
617
{
618
  cgraph_node_set_iterator csi;
619
  struct cgraph_node *node;
620
  bitmap original_nodes = lto_bitmap_alloc ();
621
  bitmap original_decls = lto_bitmap_alloc ();
622
  bitmap inlined_decls = lto_bitmap_alloc ();
623
  bool changed;
624
 
625
  /* We are going to iterate SET while adding to it, mark all original
626
     nodes so that we only add node inlined to original nodes.  */
627
  for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
628
    {
629
      bitmap_set_bit (original_nodes, csi_node (csi)->uid);
630
      bitmap_set_bit (original_decls, DECL_UID (csi_node (csi)->decl));
631
    }
632
 
633
  /* Some of the original nodes might not be needed anymore.
634
     Remove them.  */
635
  do
636
    {
637
      changed = false;
638
      for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
639
        {
640
          struct cgraph_node *inlined_to;
641
          node = csi_node (csi);
642
 
643
          /* NODE was not inlined.  We still need it.  */
644
          if (!node->global.inlined_to)
645
            continue;
646
 
647
          inlined_to = node->global.inlined_to;
648
 
649
          /* NODE should have only one caller.  */
650
          gcc_assert (!node->callers->next_caller);
651
 
652
          if (!bitmap_bit_p (original_nodes, inlined_to->uid))
653
            {
654
              bitmap_clear_bit (original_nodes, node->uid);
655
              cgraph_node_set_remove (set, node);
656
              changed = true;
657
            }
658
        }
659
    }
660
  while (changed);
661
 
662
  /* Transitively add to SET all the inline clones for every node that
663
     has been inlined.  */
664
  for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
665
    {
666
      node = csi_node (csi);
667
      if (bitmap_bit_p (original_nodes, node->uid))
668
        lto_add_inline_clones (set, node, original_decls, inlined_decls);
669
    }
670
 
671
  lto_bitmap_free (original_nodes);
672
  lto_bitmap_free (original_decls);
673
 
674
  return inlined_decls;
675
}
676
 
677
/* Owing to inlining, we may need to promote a file-scope variable
678
   to a global variable.  Consider this case:
679
 
680
   a.c:
681
   static int var;
682
 
683
   void
684
   foo (void)
685
   {
686
     var++;
687
   }
688
 
689
   b.c:
690
 
691
   extern void foo (void);
692
 
693
   void
694
   bar (void)
695
   {
696
     foo ();
697
   }
698
 
699
   If WPA inlines FOO inside BAR, then the static variable VAR needs to
700
   be promoted to global because BAR and VAR may be in different LTRANS
701
   files. */
702
 
703
/* This struct keeps track of states used in globalization.  */
704
 
705
typedef struct
706
{
707
  /* Current cgraph node set.  */
708
  cgraph_node_set set;
709
 
710
  /* Function DECLs of cgraph nodes seen.  */
711
  bitmap seen_node_decls;
712
 
713
  /* Use in walk_tree to avoid multiple visits of a node.  */
714
  struct pointer_set_t *visited;
715
 
716
  /* static vars in this set.  */
717
  bitmap static_vars_in_set;
718
 
719
  /* static vars in all previous set.  */
720
  bitmap all_static_vars;
721
 
722
  /* all vars in all previous set.  */
723
  bitmap all_vars;
724
} globalize_context_t;
725
 
726
/* Callback for walk_tree.  Examine the tree pointer to by TP and see if
727
   if its a file-scope static variable of function that need to be turned
728
   into a global.  */
729
 
730
static tree
731
globalize_cross_file_statics (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
732
                              void *data)
733
{
734
  globalize_context_t *context = (globalize_context_t *) data;
735
  tree t = *tp;
736
 
737
  if (t == NULL_TREE)
738
    return NULL;
739
 
740
  /* The logic for globalization of VAR_DECLs and FUNCTION_DECLs are
741
     different.  For functions, we can simply look at the cgraph node sets
742
     to tell if there are references to static functions outside the set.
743
     The cgraph node sets do not keep track of vars, we need to traverse
744
     the trees to determine what vars need to be globalized.  */
745
  if (TREE_CODE (t) == VAR_DECL)
746
    {
747
      if (!TREE_PUBLIC (t))
748
        {
749
          /* This file-scope static variable is reachable from more
750
             that one set.  Make it global but with hidden visibility
751
             so that we do not export it in dynamic linking.  */
752
          if (bitmap_bit_p (context->all_static_vars, DECL_UID (t)))
753
            {
754
              TREE_PUBLIC (t) = 1;
755
              DECL_VISIBILITY (t) = VISIBILITY_HIDDEN;
756
            }
757
          bitmap_set_bit (context->static_vars_in_set, DECL_UID (t));
758
        }
759
      bitmap_set_bit (context->all_vars, DECL_UID (t));
760
      walk_tree (&DECL_INITIAL (t), globalize_cross_file_statics, context,
761
                 context->visited);
762
    }
763
  else if (TREE_CODE (t) == FUNCTION_DECL && !TREE_PUBLIC (t))
764
    {
765
      if (!cgraph_node_in_set_p (cgraph_node (t), context->set))
766
        {
767
          /* This file-scope static function is reachable from a set
768
             which does not contain the function DECL.  Make it global
769
             but with hidden visibility.  */
770
          TREE_PUBLIC (t) = 1;
771
          DECL_VISIBILITY (t) = VISIBILITY_HIDDEN;
772
        }
773
    }
774
 
775
  return NULL;
776
}
777
 
778
/* Helper of lto_scan_statics_in_cgraph_node below.  Scan TABLE for
779
   static decls that may be used in more than one LTRANS file.
780
   CONTEXT is a globalize_context_t for storing scanning states.  */
781
 
782
static void
783
lto_scan_statics_in_ref_table (struct lto_tree_ref_table *table,
784
                               globalize_context_t *context)
785
{
786
  unsigned i;
787
 
788
  for (i = 0; i < table->size; i++)
789
    walk_tree (&table->trees[i], globalize_cross_file_statics, context,
790
               context->visited);
791
}
792
 
793
/* Promote file-scope decl reachable from NODE if necessary to global.
794
   CONTEXT is a globalize_context_t storing scanning states.  */
795
 
796
static void
797
lto_scan_statics_in_cgraph_node (struct cgraph_node *node,
798
                                 globalize_context_t *context)
799
{
800
  struct lto_in_decl_state *state;
801
 
802
  /* Do nothing if NODE has no function body.  */
803
  if (!node->analyzed)
804
    return;
805
 
806
  /* Return if the DECL of nodes has been visited before.  */
807
  if (bitmap_bit_p (context->seen_node_decls, DECL_UID (node->decl)))
808
    return;
809
 
810
  bitmap_set_bit (context->seen_node_decls, DECL_UID (node->decl));
811
 
812
  state = lto_get_function_in_decl_state (node->local.lto_file_data,
813
                                          node->decl);
814
  gcc_assert (state);
815
 
816
  lto_scan_statics_in_ref_table (&state->streams[LTO_DECL_STREAM_VAR_DECL],
817
                                 context);
818
  lto_scan_statics_in_ref_table (&state->streams[LTO_DECL_STREAM_FN_DECL],
819
                                 context);
820
}
821
 
822
/* Scan all global variables that we have not yet seen so far.  CONTEXT
823
   is a globalize_context_t storing scanning states.  */
824
 
825
static void
826
lto_scan_statics_in_remaining_global_vars (globalize_context_t *context)
827
{
828
  tree var, var_context;
829
  struct varpool_node *vnode;
830
 
831
  FOR_EACH_STATIC_VARIABLE (vnode)
832
    {
833
      var = vnode->decl;
834
      var_context = DECL_CONTEXT (var);
835
      if (TREE_STATIC (var)
836
          && TREE_PUBLIC (var)
837
          && (!var_context || TREE_CODE (var_context) != FUNCTION_DECL)
838
          && !bitmap_bit_p (context->all_vars, DECL_UID (var)))
839
        walk_tree (&var, globalize_cross_file_statics, context,
840
                   context->visited);
841
    }
842
}
843
 
844
/* Find out all static decls that need to be promoted to global because
845
   of cross file sharing.  This function must be run in the WPA mode after
846
   all inlinees are added.  */
847
 
848
static void
849
lto_promote_cross_file_statics (void)
850
{
851
  unsigned i, n_sets;
852
  cgraph_node_set set;
853
  cgraph_node_set_iterator csi;
854
  globalize_context_t context;
855
 
856
  memset (&context, 0, sizeof (context));
857
  context.all_vars = lto_bitmap_alloc ();
858
  context.all_static_vars = lto_bitmap_alloc ();
859
 
860
  n_sets = VEC_length (cgraph_node_set, lto_cgraph_node_sets);
861
  for (i = 0; i < n_sets; i++)
862
    {
863
      set = VEC_index (cgraph_node_set, lto_cgraph_node_sets, i);
864
      context.set = set;
865
      context.visited = pointer_set_create ();
866
      context.static_vars_in_set = lto_bitmap_alloc ();
867
      context.seen_node_decls = lto_bitmap_alloc ();
868
 
869
      for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
870
        lto_scan_statics_in_cgraph_node (csi_node (csi), &context);
871
 
872
      if (i == n_sets - 1)
873
        lto_scan_statics_in_remaining_global_vars (&context);
874
 
875
      bitmap_ior_into (context.all_static_vars, context.static_vars_in_set);
876
 
877
      pointer_set_destroy (context.visited);
878
      lto_bitmap_free (context.static_vars_in_set);
879
      lto_bitmap_free (context.seen_node_decls);
880
    }
881
 
882
  lto_bitmap_free (context.all_vars);
883
  lto_bitmap_free (context.all_static_vars);
884
}
885
 
886
 
887
/* Given a file name FNAME, return a string with FNAME prefixed with '*'.  */
888
 
889
static char *
890
prefix_name_with_star (const char *fname)
891
{
892
  char *star_fname;
893
  size_t len;
894
 
895
  len = strlen (fname) + 1 + 1;
896
  star_fname = XNEWVEC (char, len);
897
  snprintf (star_fname, len, "*%s", fname);
898
 
899
  return star_fname;
900
}
901
 
902
 
903
/* Return a copy of FNAME without the .o extension.  */
904
 
905
static char *
906
strip_extension (const char *fname)
907
{
908
  char *s = XNEWVEC (char, strlen (fname) - 2 + 1);
909
  gcc_assert (strstr (fname, ".o"));
910
  snprintf (s, strlen (fname) - 2 + 1, "%s", fname);
911
 
912
  return s;
913
}
914
 
915
 
916
/* Return a file name associated with cgraph node set SET.  This may
917
   be a new temporary file name if SET needs to be processed by
918
   LTRANS, or the original file name if all the nodes in SET belong to
919
   the same input file.  */
920
 
921
static char *
922
get_filename_for_set (cgraph_node_set set)
923
{
924
  char *fname = NULL;
925
  static const size_t max_fname_len = 100;
926
 
927
  if (cgraph_node_set_needs_ltrans_p (set))
928
    {
929
      /* Create a new temporary file to store SET.  To facilitate
930
         debugging, use file names from SET as part of the new
931
         temporary file name.  */
932
      cgraph_node_set_iterator si;
933
      struct pointer_set_t *pset = pointer_set_create ();
934
      for (si = csi_start (set); !csi_end_p (si); csi_next (&si))
935
        {
936
          struct cgraph_node *n = csi_node (si);
937
          const char *node_fname;
938
          char *f;
939
 
940
          /* Don't use the same file name more than once.  */
941
          if (pointer_set_insert (pset, n->local.lto_file_data))
942
            continue;
943
 
944
          /* The first file name found in SET determines the output
945
             directory.  For the remaining files, we use their
946
             base names.  */
947
          node_fname = n->local.lto_file_data->file_name;
948
          if (fname == NULL)
949
            {
950
              fname = strip_extension (node_fname);
951
              continue;
952
            }
953
 
954
          f = strip_extension (lbasename (node_fname));
955
 
956
          /* If the new name causes an excessively long file name,
957
             make the last component "___" to indicate overflow.  */
958
          if (strlen (fname) + strlen (f) > max_fname_len - 3)
959
            {
960
              fname = reconcat (fname, fname, "___", NULL);
961
              break;
962
            }
963
          else
964
            {
965
              fname = reconcat (fname, fname, "_", f, NULL);
966
              free (f);
967
            }
968
        }
969
 
970
      pointer_set_destroy (pset);
971
 
972
      /* Add the extension .wpa.o to indicate that this file has been
973
         produced by WPA.  */
974
      fname = reconcat (fname, fname, ".wpa.o", NULL);
975
      gcc_assert (fname);
976
    }
977
  else
978
    {
979
      /* Since SET does not need to be processed by LTRANS, use
980
         the original file name and mark it with a '*' prefix so that
981
         lto_execute_ltrans knows not to process it.  */
982
      cgraph_node_set_iterator si = csi_start (set);
983
      struct cgraph_node *first = csi_node (si);
984
      fname = prefix_name_with_star (first->local.lto_file_data->file_name);
985
    }
986
 
987
  return fname;
988
}
989
 
990
static lto_file *current_lto_file;
991
 
992
 
993
/* Write all output files in WPA mode.  Returns a NULL-terminated array of
994
   output file names.  */
995
 
996
static char **
997
lto_wpa_write_files (void)
998
{
999
  char **output_files;
1000
  unsigned i, n_sets, last_out_file_ix, num_out_files;
1001
  lto_file *file;
1002
  cgraph_node_set set;
1003
  bitmap decls;
1004
  VEC(bitmap,heap) *inlined_decls = NULL;
1005
 
1006
  timevar_push (TV_WHOPR_WPA);
1007
 
1008
  /* Include all inlined functions and determine what sets need to be
1009
     compiled by LTRANS.  After this loop, only those sets that
1010
     contain callgraph nodes from more than one file will need to be
1011
     compiled by LTRANS.  */
1012
  for (i = 0; VEC_iterate (cgraph_node_set, lto_cgraph_node_sets, i, set); i++)
1013
    {
1014
      decls = lto_add_all_inlinees (set);
1015
      VEC_safe_push (bitmap, heap, inlined_decls, decls);
1016
      lto_stats.num_output_cgraph_nodes += VEC_length (cgraph_node_ptr,
1017
                                                       set->nodes);
1018
    }
1019
 
1020
  /* After adding all inlinees, find out statics that need to be promoted
1021
     to globals because of cross-file inlining.  */
1022
  lto_promote_cross_file_statics ();
1023
 
1024
  timevar_pop (TV_WHOPR_WPA);
1025
 
1026
  timevar_push (TV_WHOPR_WPA_IO);
1027
 
1028
  /* The number of output files depends on the number of input files
1029
     and how many callgraph node sets we create.  Reserve enough space
1030
     for the maximum of these two.  */
1031
  num_out_files = MAX (VEC_length (cgraph_node_set, lto_cgraph_node_sets),
1032
                       num_in_fnames);
1033
  output_files = XNEWVEC (char *, num_out_files + 1);
1034
 
1035
  n_sets = VEC_length (cgraph_node_set, lto_cgraph_node_sets);
1036
  for (i = 0; i < n_sets; i++)
1037
    {
1038
      char *temp_filename;
1039
 
1040
      set = VEC_index (cgraph_node_set, lto_cgraph_node_sets, i);
1041
      temp_filename = get_filename_for_set (set);
1042
      output_files[i] = temp_filename;
1043
 
1044
      if (cgraph_node_set_needs_ltrans_p (set))
1045
        {
1046
          /* Write all the nodes in SET to TEMP_FILENAME.  */
1047
          file = lto_obj_file_open (temp_filename, true);
1048
          if (!file)
1049
            fatal_error ("lto_obj_file_open() failed");
1050
 
1051
          lto_set_current_out_file (file);
1052
          lto_new_extern_inline_states ();
1053
 
1054
          decls = VEC_index (bitmap, inlined_decls, i);
1055
          lto_force_functions_extern_inline (decls);
1056
 
1057
          ipa_write_summaries_of_cgraph_node_set (set);
1058
          lto_delete_extern_inline_states ();
1059
 
1060
          lto_set_current_out_file (NULL);
1061
          lto_obj_file_close (file);
1062
        }
1063
    }
1064
 
1065
  last_out_file_ix = n_sets;
1066
 
1067
  lto_stats.num_output_files += n_sets;
1068
 
1069
  output_files[last_out_file_ix] = NULL;
1070
 
1071
  for (i = 0; VEC_iterate (bitmap, inlined_decls, i, decls); i++)
1072
    lto_bitmap_free (decls);
1073
  VEC_free (bitmap, heap, inlined_decls);
1074
 
1075
  timevar_pop (TV_WHOPR_WPA_IO);
1076
 
1077
  return output_files;
1078
}
1079
 
1080
/* Template of LTRANS dumpbase suffix.  */
1081
#define DUMPBASE_SUFFIX ".ltrans18446744073709551615"
1082
 
1083
/* Perform local transformations (LTRANS) on the files in the NULL-terminated
1084
   FILES array.  These should have been written previously by
1085
   lto_wpa_write_files ().  Transformations are performed via executing
1086
   COLLECT_GCC for reach file.  */
1087
 
1088
static void
1089
lto_execute_ltrans (char *const *files)
1090
{
1091
  struct pex_obj *pex;
1092
  const char *collect_gcc_options, *collect_gcc;
1093
  struct obstack env_obstack;
1094
  const char **argv;
1095
  const char **argv_ptr;
1096
  const char *errmsg;
1097
  size_t i, j;
1098
  int err;
1099
  int status;
1100
  FILE *ltrans_output_list_stream = NULL;
1101
  bool seen_dumpbase = false;
1102
  char *dumpbase_suffix = NULL;
1103
 
1104
  timevar_push (TV_WHOPR_WPA_LTRANS_EXEC);
1105
 
1106
  /* Get the driver and options.  */
1107
  collect_gcc = getenv ("COLLECT_GCC");
1108
  if (!collect_gcc)
1109
    fatal_error ("environment variable COLLECT_GCC must be set");
1110
 
1111
  /* Set the CFLAGS environment variable.  */
1112
  collect_gcc_options = getenv ("COLLECT_GCC_OPTIONS");
1113
  if (!collect_gcc_options)
1114
    fatal_error ("environment variable COLLECT_GCC_OPTIONS must be set");
1115
 
1116
  /* Count arguments.  */
1117
  i = 0;
1118
  for (j = 0; collect_gcc_options[j] != '\0'; ++j)
1119
    if (collect_gcc_options[j] == '\'')
1120
      ++i;
1121
 
1122
  if (i % 2 != 0)
1123
    fatal_error ("malformed COLLECT_GCC_OPTIONS");
1124
 
1125
  /* Initalize the arguments for the LTRANS driver.  */
1126
  argv = XNEWVEC (const char *, 8 + i / 2);
1127
  argv_ptr = argv;
1128
  *argv_ptr++ = collect_gcc;
1129
  *argv_ptr++ = "-xlto";
1130
  for (j = 0; collect_gcc_options[j] != '\0'; ++j)
1131
    if (collect_gcc_options[j] == '\'')
1132
      {
1133
        char *option;
1134
 
1135
        ++j;
1136
        i = j;
1137
        while (collect_gcc_options[j] != '\'')
1138
          ++j;
1139
        obstack_init (&env_obstack);
1140
        obstack_grow (&env_obstack, &collect_gcc_options[i], j - i);
1141
        if (seen_dumpbase)
1142
          obstack_grow (&env_obstack, DUMPBASE_SUFFIX,
1143
                        sizeof (DUMPBASE_SUFFIX));
1144
        else
1145
          obstack_1grow (&env_obstack, 0);
1146
        option = XOBFINISH (&env_obstack, char *);
1147
        if (seen_dumpbase)
1148
          {
1149
            dumpbase_suffix = option + 7 + j - i;
1150
            seen_dumpbase = false;
1151
          }
1152
 
1153
        /* LTRANS does not need -fwpa nor -fltrans-*.  */
1154
        if (strncmp (option, "-fwpa", 5) != 0
1155
            && strncmp (option, "-fltrans-", 9) != 0)
1156
          {
1157
            if (strncmp (option, "-dumpbase", 9) == 0)
1158
              seen_dumpbase = true;
1159
            *argv_ptr++ = option;
1160
          }
1161
      }
1162
  *argv_ptr++ = "-fltrans";
1163
 
1164
  /* Open the LTRANS output list.  */
1165
  if (ltrans_output_list)
1166
    {
1167
      ltrans_output_list_stream = fopen (ltrans_output_list, "w");
1168
      if (ltrans_output_list_stream == NULL)
1169
        error ("opening LTRANS output list %s: %m", ltrans_output_list);
1170
    }
1171
 
1172
  for (i = 0; files[i]; ++i)
1173
    {
1174
      size_t len;
1175
 
1176
      /* If the file is prefixed with a '*', it means that we do not
1177
         need to re-compile it with LTRANS because it has not been
1178
         modified by WPA.  Skip it from the command line to
1179
         lto_execute_ltrans, but add it to ltrans_output_list_stream
1180
         so it is linked after we are done.  */
1181
      if (files[i][0] == '*')
1182
        {
1183
          size_t len = strlen (files[i]) - 1;
1184
          if (ltrans_output_list_stream)
1185
            if (fwrite (&files[i][1], 1, len, ltrans_output_list_stream) < len
1186
                || fwrite ("\n", 1, 1, ltrans_output_list_stream) < 1)
1187
              error ("writing to LTRANS output list %s: %m",
1188
                     ltrans_output_list);
1189
        }
1190
      else
1191
        {
1192
          char *output_name;
1193
 
1194
          /* Otherwise, add FILES[I] to lto_execute_ltrans command line
1195
             and add the resulting file to LTRANS output list.  */
1196
 
1197
          /* Replace the .o suffix with a .ltrans.o suffix and write
1198
             the resulting name to the LTRANS output list.  */
1199
          obstack_init (&env_obstack);
1200
          obstack_grow (&env_obstack, files[i], strlen (files[i]) - 2);
1201
          obstack_grow (&env_obstack, ".ltrans.o", sizeof (".ltrans.o"));
1202
          output_name = XOBFINISH (&env_obstack, char *);
1203
          if (ltrans_output_list_stream)
1204
            {
1205
              len = strlen (output_name);
1206
 
1207
              if (fwrite (output_name, 1, len, ltrans_output_list_stream) < len
1208
                  || fwrite ("\n", 1, 1, ltrans_output_list_stream) < 1)
1209
                error ("writing to LTRANS output list %s: %m",
1210
                       ltrans_output_list);
1211
            }
1212
 
1213
          argv_ptr[0] = "-o";
1214
          argv_ptr[1] = output_name;
1215
          argv_ptr[2] = files[i];
1216
          argv_ptr[3] = NULL;
1217
 
1218
          /* Append a sequence number to -dumpbase for LTRANS.  */
1219
          if (dumpbase_suffix)
1220
            snprintf (dumpbase_suffix, sizeof (DUMPBASE_SUFFIX) - 7,
1221
                      "%lu", (unsigned long) i);
1222
 
1223
          /* Execute the driver.  */
1224
          pex = pex_init (0, "lto1", NULL);
1225
          if (pex == NULL)
1226
            fatal_error ("pex_init failed: %s", xstrerror (errno));
1227
 
1228
          errmsg = pex_run (pex, PEX_LAST | PEX_SEARCH, argv[0],
1229
                            CONST_CAST (char **, argv), NULL, NULL, &err);
1230
          if (errmsg)
1231
            fatal_error ("%s: %s", errmsg, xstrerror (err));
1232
 
1233
          if (!pex_get_status (pex, 1, &status))
1234
            fatal_error ("can't get program status: %s", xstrerror (errno));
1235
 
1236
          if (status)
1237
            {
1238
              if (WIFSIGNALED (status))
1239
                {
1240
                  int sig = WTERMSIG (status);
1241
                  fatal_error ("%s terminated with signal %d [%s]%s",
1242
                               argv[0], sig, strsignal (sig),
1243
                               WCOREDUMP (status) ? ", core dumped" : "");
1244
                }
1245
              else
1246
                fatal_error ("%s terminated with status %d", argv[0], status);
1247
            }
1248
 
1249
          pex_free (pex);
1250
        }
1251
    }
1252
 
1253
  /* Close the LTRANS output list.  */
1254
  if (ltrans_output_list_stream && fclose (ltrans_output_list_stream))
1255
    error ("closing LTRANS output list %s: %m", ltrans_output_list);
1256
 
1257
  obstack_free (&env_obstack, NULL);
1258
  free (argv);
1259
 
1260
  timevar_pop (TV_WHOPR_WPA_LTRANS_EXEC);
1261
}
1262
 
1263
 
1264
typedef struct {
1265
  struct pointer_set_t *seen;
1266
} lto_fixup_data_t;
1267
 
1268
#define LTO_FIXUP_SUBTREE(t) \
1269
  do \
1270
    walk_tree (&(t), lto_fixup_tree, data, NULL); \
1271
  while (0)
1272
 
1273
#define LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE(t) \
1274
  do \
1275
    { \
1276
      if (t) \
1277
        (t) = gimple_register_type (t); \
1278
      walk_tree (&(t), lto_fixup_tree, data, NULL); \
1279
    } \
1280
  while (0)
1281
 
1282
static tree lto_fixup_tree (tree *, int *, void *);
1283
 
1284
/* Return true if T does not need to be fixed up recursively.  */
1285
 
1286
static inline bool
1287
no_fixup_p (tree t)
1288
{
1289
  return (t == NULL
1290
          || CONSTANT_CLASS_P (t)
1291
          || TREE_CODE (t) == IDENTIFIER_NODE);
1292
}
1293
 
1294
/* Fix up fields of a tree_common T.  DATA points to fix-up states.  */
1295
 
1296
static void
1297
lto_fixup_common (tree t, void *data)
1298
{
1299
  /* The following re-creates the TYPE_REFERENCE_TO and TYPE_POINTER_TO
1300
     lists.  We do not stream TYPE_REFERENCE_TO, TYPE_POINTER_TO or
1301
     TYPE_NEXT_PTR_TO and TYPE_NEXT_REF_TO.
1302
     First remove us from any pointer list we are on.  */
1303
  if (TREE_CODE (t) == POINTER_TYPE)
1304
    {
1305
      if (TYPE_POINTER_TO (TREE_TYPE (t)) == t)
1306
        TYPE_POINTER_TO (TREE_TYPE (t)) = TYPE_NEXT_PTR_TO (t);
1307
      else
1308
        {
1309
          tree tem = TYPE_POINTER_TO (TREE_TYPE (t));
1310
          while (tem && TYPE_NEXT_PTR_TO (tem) != t)
1311
            tem = TYPE_NEXT_PTR_TO (tem);
1312
          if (tem)
1313
            TYPE_NEXT_PTR_TO (tem) = TYPE_NEXT_PTR_TO (t);
1314
        }
1315
      TYPE_NEXT_PTR_TO (t) = NULL_TREE;
1316
    }
1317
  else if (TREE_CODE (t) == REFERENCE_TYPE)
1318
    {
1319
      if (TYPE_REFERENCE_TO (TREE_TYPE (t)) == t)
1320
        TYPE_REFERENCE_TO (TREE_TYPE (t)) = TYPE_NEXT_REF_TO (t);
1321
      else
1322
        {
1323
          tree tem = TYPE_REFERENCE_TO (TREE_TYPE (t));
1324
          while (tem && TYPE_NEXT_REF_TO (tem) != t)
1325
            tem = TYPE_NEXT_REF_TO (tem);
1326
          if (tem)
1327
            TYPE_NEXT_REF_TO (tem) = TYPE_NEXT_REF_TO (t);
1328
        }
1329
      TYPE_NEXT_REF_TO (t) = NULL_TREE;
1330
    }
1331
 
1332
  /* Fixup our type.  */
1333
  LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TREE_TYPE (t));
1334
 
1335
  /* Second put us on the list of pointers of the new pointed-to type
1336
     if we are a main variant.  This is done in lto_fixup_type after
1337
     fixing up our main variant.  */
1338
 
1339
  /* This is not very efficient because we cannot do tail-recursion with
1340
     a long chain of trees. */
1341
  LTO_FIXUP_SUBTREE (TREE_CHAIN (t));
1342
}
1343
 
1344
/* Fix up fields of a decl_minimal T.  DATA points to fix-up states.  */
1345
 
1346
static void
1347
lto_fixup_decl_minimal (tree t, void *data)
1348
{
1349
  lto_fixup_common (t, data);
1350
  LTO_FIXUP_SUBTREE (DECL_NAME (t));
1351
  LTO_FIXUP_SUBTREE (DECL_CONTEXT (t));
1352
}
1353
 
1354
/* Fix up fields of a decl_common T.  DATA points to fix-up states.  */
1355
 
1356
static void
1357
lto_fixup_decl_common (tree t, void *data)
1358
{
1359
  lto_fixup_decl_minimal (t, data);
1360
  LTO_FIXUP_SUBTREE (DECL_SIZE (t));
1361
  LTO_FIXUP_SUBTREE (DECL_SIZE_UNIT (t));
1362
  LTO_FIXUP_SUBTREE (DECL_INITIAL (t));
1363
  LTO_FIXUP_SUBTREE (DECL_ATTRIBUTES (t));
1364
  LTO_FIXUP_SUBTREE (DECL_ABSTRACT_ORIGIN (t));
1365
}
1366
 
1367
/* Fix up fields of a decl_with_vis T.  DATA points to fix-up states.  */
1368
 
1369
static void
1370
lto_fixup_decl_with_vis (tree t, void *data)
1371
{
1372
  lto_fixup_decl_common (t, data);
1373
 
1374
  /* Accessor macro has side-effects, use field-name here. */
1375
  LTO_FIXUP_SUBTREE (t->decl_with_vis.assembler_name);
1376
 
1377
  gcc_assert (no_fixup_p (DECL_SECTION_NAME (t)));
1378
}
1379
 
1380
/* Fix up fields of a decl_non_common T.  DATA points to fix-up states.  */
1381
 
1382
static void
1383
lto_fixup_decl_non_common (tree t, void *data)
1384
{
1385
  lto_fixup_decl_with_vis (t, data);
1386
  LTO_FIXUP_SUBTREE (DECL_ARGUMENT_FLD (t));
1387
  LTO_FIXUP_SUBTREE (DECL_RESULT_FLD (t));
1388
  LTO_FIXUP_SUBTREE (DECL_VINDEX (t));
1389
 
1390
  /* SAVED_TREE should not cleared by now.  Also no accessor for base type. */
1391
  gcc_assert (no_fixup_p (t->decl_non_common.saved_tree));
1392
}
1393
 
1394
/* Fix up fields of a decl_non_common T.  DATA points to fix-up states.  */
1395
 
1396
static void
1397
lto_fixup_function (tree t, void *data)
1398
{
1399
  lto_fixup_decl_non_common (t, data);
1400
  LTO_FIXUP_SUBTREE (DECL_FUNCTION_PERSONALITY (t));
1401
}
1402
 
1403
/* Fix up fields of a field_decl T.  DATA points to fix-up states.  */
1404
 
1405
static void
1406
lto_fixup_field_decl (tree t, void *data)
1407
{
1408
  lto_fixup_decl_common (t, data);
1409
  LTO_FIXUP_SUBTREE (DECL_FIELD_OFFSET (t));
1410
  LTO_FIXUP_SUBTREE (DECL_BIT_FIELD_TYPE (t));
1411
  LTO_FIXUP_SUBTREE (DECL_QUALIFIER (t));
1412
  gcc_assert (no_fixup_p (DECL_FIELD_BIT_OFFSET (t)));
1413
  LTO_FIXUP_SUBTREE (DECL_FCONTEXT (t));
1414
}
1415
 
1416
/* Fix up fields of a type T.  DATA points to fix-up states.  */
1417
 
1418
static void
1419
lto_fixup_type (tree t, void *data)
1420
{
1421
  tree tem, mv;
1422
 
1423
  lto_fixup_common (t, data);
1424
  LTO_FIXUP_SUBTREE (TYPE_CACHED_VALUES (t));
1425
  LTO_FIXUP_SUBTREE (TYPE_SIZE (t));
1426
  LTO_FIXUP_SUBTREE (TYPE_SIZE_UNIT (t));
1427
  LTO_FIXUP_SUBTREE (TYPE_ATTRIBUTES (t));
1428
  LTO_FIXUP_SUBTREE (TYPE_NAME (t));
1429
 
1430
  /* Accessors are for derived node types only. */
1431
  if (!POINTER_TYPE_P (t))
1432
    LTO_FIXUP_SUBTREE (t->type.minval);
1433
  LTO_FIXUP_SUBTREE (t->type.maxval);
1434
 
1435
  /* Accessor is for derived node types only. */
1436
  LTO_FIXUP_SUBTREE (t->type.binfo);
1437
 
1438
  if (TYPE_CONTEXT (t))
1439
    {
1440
      if (TYPE_P (TYPE_CONTEXT (t)))
1441
        LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TYPE_CONTEXT (t));
1442
      else
1443
        LTO_FIXUP_SUBTREE (TYPE_CONTEXT (t));
1444
    }
1445
  LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TYPE_CANONICAL (t));
1446
 
1447
  /* The following re-creates proper variant lists while fixing up
1448
     the variant leaders.  We do not stream TYPE_NEXT_VARIANT so the
1449
     variant list state before fixup is broken.  */
1450
 
1451
  /* Remove us from our main variant list if we are not the variant leader.  */
1452
  if (TYPE_MAIN_VARIANT (t) != t)
1453
    {
1454
      tem = TYPE_MAIN_VARIANT (t);
1455
      while (tem && TYPE_NEXT_VARIANT (tem) != t)
1456
        tem = TYPE_NEXT_VARIANT (tem);
1457
      if (tem)
1458
        TYPE_NEXT_VARIANT (tem) = TYPE_NEXT_VARIANT (t);
1459
      TYPE_NEXT_VARIANT (t) = NULL_TREE;
1460
    }
1461
 
1462
  /* Query our new main variant.  */
1463
  mv = gimple_register_type (TYPE_MAIN_VARIANT (t));
1464
 
1465
  /* If we were the variant leader and we get replaced ourselves drop
1466
     all variants from our list.  */
1467
  if (TYPE_MAIN_VARIANT (t) == t
1468
      && mv != t)
1469
    {
1470
      tem = t;
1471
      while (tem)
1472
        {
1473
          tree tem2 = TYPE_NEXT_VARIANT (tem);
1474
          TYPE_NEXT_VARIANT (tem) = NULL_TREE;
1475
          tem = tem2;
1476
        }
1477
    }
1478
 
1479
  /* If we are not our own variant leader link us into our new leaders
1480
     variant list.  */
1481
  if (mv != t)
1482
    {
1483
      TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (mv);
1484
      TYPE_NEXT_VARIANT (mv) = t;
1485
    }
1486
 
1487
  /* Finally adjust our main variant and fix it up.  */
1488
  TYPE_MAIN_VARIANT (t) = mv;
1489
  LTO_FIXUP_SUBTREE (TYPE_MAIN_VARIANT (t));
1490
 
1491
  /* As the second step of reconstructing the pointer chains put us
1492
     on the list of pointers of the new pointed-to type
1493
     if we are a main variant.  See lto_fixup_common for the first step.  */
1494
  if (TREE_CODE (t) == POINTER_TYPE
1495
      && TYPE_MAIN_VARIANT (t) == t)
1496
    {
1497
      TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (TREE_TYPE (t));
1498
      TYPE_POINTER_TO (TREE_TYPE (t)) = t;
1499
    }
1500
  else if (TREE_CODE (t) == REFERENCE_TYPE
1501
           && TYPE_MAIN_VARIANT (t) == t)
1502
    {
1503
      TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (TREE_TYPE (t));
1504
      TYPE_REFERENCE_TO (TREE_TYPE (t)) = t;
1505
    }
1506
}
1507
 
1508
/* Fix up fields of a BINFO T.  DATA points to fix-up states.  */
1509
 
1510
static void
1511
lto_fixup_binfo (tree t, void *data)
1512
{
1513
  unsigned HOST_WIDE_INT i, n;
1514
  tree base, saved_base;
1515
 
1516
  lto_fixup_common (t, data);
1517
  gcc_assert (no_fixup_p (BINFO_OFFSET (t)));
1518
  LTO_FIXUP_SUBTREE (BINFO_VTABLE (t));
1519
  LTO_FIXUP_SUBTREE (BINFO_VIRTUALS (t));
1520
  LTO_FIXUP_SUBTREE (BINFO_VPTR_FIELD (t));
1521
  n = VEC_length (tree, BINFO_BASE_ACCESSES (t));
1522
  for (i = 0; i < n; i++)
1523
    {
1524
      saved_base = base = BINFO_BASE_ACCESS (t, i);
1525
      LTO_FIXUP_SUBTREE (base);
1526
      if (base != saved_base)
1527
        VEC_replace (tree, BINFO_BASE_ACCESSES (t), i, base);
1528
    }
1529
  LTO_FIXUP_SUBTREE (BINFO_INHERITANCE_CHAIN (t));
1530
  LTO_FIXUP_SUBTREE (BINFO_SUBVTT_INDEX (t));
1531
  LTO_FIXUP_SUBTREE (BINFO_VPTR_INDEX (t));
1532
  n = BINFO_N_BASE_BINFOS (t);
1533
  for (i = 0; i < n; i++)
1534
    {
1535
      saved_base = base = BINFO_BASE_BINFO (t, i);
1536
      LTO_FIXUP_SUBTREE (base);
1537
      if (base != saved_base)
1538
        VEC_replace (tree, BINFO_BASE_BINFOS (t), i, base);
1539
    }
1540
}
1541
 
1542
/* Fix up fields of a CONSTRUCTOR T.  DATA points to fix-up states.  */
1543
 
1544
static void
1545
lto_fixup_constructor (tree t, void *data)
1546
{
1547
  unsigned HOST_WIDE_INT idx;
1548
  constructor_elt *ce;
1549
 
1550
  LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TREE_TYPE (t));
1551
 
1552
  for (idx = 0;
1553
       VEC_iterate(constructor_elt, CONSTRUCTOR_ELTS (t), idx, ce);
1554
       idx++)
1555
    {
1556
      LTO_FIXUP_SUBTREE (ce->index);
1557
      LTO_FIXUP_SUBTREE (ce->value);
1558
    }
1559
}
1560
 
1561
/* A walk_tree callback used by lto_fixup_state. TP is the pointer to the
1562
   current tree. WALK_SUBTREES indicates if the subtrees will be walked.
1563
   DATA is a pointer set to record visited nodes. */
1564
 
1565
static tree
1566
lto_fixup_tree (tree *tp, int *walk_subtrees, void *data)
1567
{
1568
  tree t;
1569
  lto_fixup_data_t *fixup_data = (lto_fixup_data_t *) data;
1570
  tree prevailing;
1571
 
1572
  t = *tp;
1573
  *walk_subtrees = 0;
1574
  if (pointer_set_contains (fixup_data->seen, t))
1575
    return NULL;
1576
 
1577
  if (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == FUNCTION_DECL)
1578
    {
1579
      prevailing = lto_symtab_prevailing_decl (t);
1580
 
1581
      if (t != prevailing)
1582
        {
1583
          if (TREE_CODE (t) == FUNCTION_DECL
1584
              && TREE_NOTHROW (prevailing) != TREE_NOTHROW (t))
1585
            {
1586
              /* If the prevailing definition does not throw but the
1587
                 declaration (T) was considered throwing, then we
1588
                 simply add PREVAILING to the list of throwing
1589
                 functions.  However, if the opposite is true, then
1590
                 the call to PREVAILING was generated assuming that
1591
                 the function didn't throw, which means that CFG
1592
                 cleanup may have removed surrounding try/catch
1593
                 regions.
1594
 
1595
                 Note that we currently accept these cases even when
1596
                 they occur within a single file.  It's certainly a
1597
                 user error, but we silently allow the compiler to
1598
                 remove surrounding try/catch regions.  Perhaps we
1599
                 could emit a warning here, instead of silently
1600
                 accepting the conflicting declaration.  */
1601
              if (TREE_NOTHROW (prevailing))
1602
                lto_mark_nothrow_fndecl (prevailing);
1603
            }
1604
 
1605
           /* Also replace t with prevailing defintion.  We don't want to
1606
              insert the other defintion in the seen set as we want to
1607
              replace all instances of it.  */
1608
          *tp = prevailing;
1609
          t = prevailing;
1610
        }
1611
    }
1612
  else if (TYPE_P (t))
1613
    {
1614
      /* Replace t with the prevailing type.  We don't want to insert the
1615
         other type in the seen set as we want to replace all instances of it.  */
1616
      t = gimple_register_type (t);
1617
      *tp = t;
1618
    }
1619
 
1620
  if (pointer_set_insert (fixup_data->seen, t))
1621
    return NULL;
1622
 
1623
  /* walk_tree does not visit all reachable nodes that need to be fixed up.
1624
     Hence we do special processing here for those kind of nodes. */
1625
  switch (TREE_CODE (t))
1626
    {
1627
    case FIELD_DECL:
1628
      lto_fixup_field_decl (t, data);
1629
      break;
1630
 
1631
    case LABEL_DECL:
1632
    case CONST_DECL:
1633
    case PARM_DECL:
1634
    case RESULT_DECL:
1635
    case IMPORTED_DECL:
1636
      lto_fixup_decl_common (t, data);
1637
      break;
1638
 
1639
    case VAR_DECL:
1640
      lto_fixup_decl_with_vis (t, data);
1641
      break;
1642
 
1643
    case TYPE_DECL:
1644
      lto_fixup_decl_non_common (t, data);
1645
      break;
1646
 
1647
    case FUNCTION_DECL:
1648
      lto_fixup_function (t, data);
1649
      break;
1650
 
1651
    case TREE_BINFO:
1652
      lto_fixup_binfo (t, data);
1653
      break;
1654
 
1655
    default:
1656
      if (TYPE_P (t))
1657
        lto_fixup_type (t, data);
1658
      else if (TREE_CODE (t) == CONSTRUCTOR)
1659
        lto_fixup_constructor (t, data);
1660
      else if (CONSTANT_CLASS_P (t))
1661
        LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TREE_TYPE (t));
1662
      else if (EXPR_P (t))
1663
        {
1664
          /* walk_tree only handles TREE_OPERANDs. Do the rest here.  */
1665
          lto_fixup_common (t, data);
1666
          LTO_FIXUP_SUBTREE (t->exp.block);
1667
          *walk_subtrees = 1;
1668
        }
1669
      else
1670
        {
1671
          /* Let walk_tree handle sub-trees.  */
1672
          *walk_subtrees = 1;
1673
        }
1674
    }
1675
 
1676
  return NULL;
1677
}
1678
 
1679
/* Helper function of lto_fixup_decls. Walks the var and fn streams in STATE,
1680
   replaces var and function decls with the corresponding prevailing def and
1681
   records the old decl in the free-list in DATA. We also record visted nodes
1682
   in the seen-set in DATA to avoid multiple visit for nodes that need not
1683
   to be replaced.  */
1684
 
1685
static void
1686
lto_fixup_state (struct lto_in_decl_state *state, lto_fixup_data_t *data)
1687
{
1688
  unsigned i, si;
1689
  struct lto_tree_ref_table *table;
1690
 
1691
  /* Although we only want to replace FUNCTION_DECLs and VAR_DECLs,
1692
     we still need to walk from all DECLs to find the reachable
1693
     FUNCTION_DECLs and VAR_DECLs.  */
1694
  for (si = 0; si < LTO_N_DECL_STREAMS; si++)
1695
    {
1696
      table = &state->streams[si];
1697
      for (i = 0; i < table->size; i++)
1698
        walk_tree (table->trees + i, lto_fixup_tree, data, NULL);
1699
    }
1700
}
1701
 
1702
/* A callback of htab_traverse. Just extract a state from SLOT and the
1703
   lto_fixup_data_t object from AUX and calls lto_fixup_state. */
1704
 
1705
static int
1706
lto_fixup_state_aux (void **slot, void *aux)
1707
{
1708
  struct lto_in_decl_state *state = (struct lto_in_decl_state *) *slot;
1709
  lto_fixup_state (state, (lto_fixup_data_t *) aux);
1710
  return 1;
1711
}
1712
 
1713
/* Fix the decls from all FILES. Replaces each decl with the corresponding
1714
   prevailing one.  */
1715
 
1716
static void
1717
lto_fixup_decls (struct lto_file_decl_data **files)
1718
{
1719
  unsigned int i;
1720
  tree decl;
1721
  struct pointer_set_t *seen = pointer_set_create ();
1722
  lto_fixup_data_t data;
1723
 
1724
  data.seen = seen;
1725
  for (i = 0; files[i]; i++)
1726
    {
1727
      struct lto_file_decl_data *file = files[i];
1728
      struct lto_in_decl_state *state = file->global_decl_state;
1729
      lto_fixup_state (state, &data);
1730
 
1731
      htab_traverse (file->function_decl_states, lto_fixup_state_aux, &data);
1732
    }
1733
 
1734
  for (i = 0; VEC_iterate (tree, lto_global_var_decls, i, decl); i++)
1735
    {
1736
      tree saved_decl = decl;
1737
      walk_tree (&decl, lto_fixup_tree, &data, NULL);
1738
      if (decl != saved_decl)
1739
        VEC_replace (tree, lto_global_var_decls, i, decl);
1740
    }
1741
 
1742
  pointer_set_destroy (seen);
1743
}
1744
 
1745
/* Unlink a temporary LTRANS file unless requested otherwise.  */
1746
 
1747
static void
1748
lto_maybe_unlink (const char *file)
1749
{
1750
  if (!getenv ("WPA_SAVE_LTRANS"))
1751
    {
1752
      if (unlink_if_ordinary (file))
1753
        error ("deleting LTRANS input file %s: %m", file);
1754
    }
1755
  else
1756
    fprintf (stderr, "[Leaving LTRANS input file %s]\n", file);
1757
}
1758
 
1759
/* Read the options saved from each file in the command line.  Called
1760
   from lang_hooks.post_options which is called by process_options
1761
   right before all the options are used to initialize the compiler.
1762
   This assumes that decode_options has already run, so the
1763
   num_in_fnames and in_fnames are properly set.
1764
 
1765
   Note that this assumes that all the files had been compiled with
1766
   the same options, which is not a good assumption.  In general,
1767
   options ought to be read from all the files in the set and merged.
1768
   However, it is still unclear what the merge rules should be.  */
1769
 
1770
void
1771
lto_read_all_file_options (void)
1772
{
1773
  size_t i;
1774
 
1775
  /* Clear any file options currently saved.  */
1776
  lto_clear_file_options ();
1777
 
1778
  /* Set the hooks to read ELF sections.  */
1779
  lto_set_in_hooks (NULL, get_section_data, free_section_data);
1780
 
1781
  for (i = 0; i < num_in_fnames; i++)
1782
    {
1783
      struct lto_file_decl_data *file_data;
1784
      lto_file *file = lto_obj_file_open (in_fnames[i], false);
1785
      if (!file)
1786
        break;
1787
 
1788
      file_data = XCNEW (struct lto_file_decl_data);
1789
      file_data->file_name = file->filename;
1790
      file_data->section_hash_table = lto_obj_build_section_table (file);
1791
 
1792
      lto_read_file_options (file_data);
1793
 
1794
      lto_obj_file_close (file);
1795
      htab_delete (file_data->section_hash_table);
1796
      free (file_data);
1797
    }
1798
 
1799
  /* Apply globally the options read from all the files.  */
1800
  lto_reissue_options ();
1801
}
1802
 
1803
 
1804
/* Read all the symbols from the input files FNAMES.  NFILES is the
1805
   number of files requested in the command line.  Instantiate a
1806
   global call graph by aggregating all the sub-graphs found in each
1807
   file.  */
1808
 
1809
static void
1810
read_cgraph_and_symbols (unsigned nfiles, const char **fnames)
1811
{
1812
  unsigned int i, last_file_ix;
1813
  struct lto_file_decl_data **all_file_decl_data;
1814
  FILE *resolution;
1815
  struct cgraph_node *node;
1816
 
1817
  lto_stats.num_input_files = nfiles;
1818
 
1819
  timevar_push (TV_IPA_LTO_DECL_IO);
1820
 
1821
  /* Set the hooks so that all of the ipa passes can read in their data.  */
1822
  all_file_decl_data = XNEWVEC (struct lto_file_decl_data *, nfiles + 1);
1823
  lto_set_in_hooks (all_file_decl_data, get_section_data, free_section_data);
1824
 
1825
  /* Read the resolution file.  */
1826
  resolution = NULL;
1827
  if (resolution_file_name)
1828
    {
1829
      int t;
1830
      unsigned num_objects;
1831
 
1832
      resolution = fopen (resolution_file_name, "r");
1833
      if (resolution == NULL)
1834
        fatal_error ("could not open symbol resolution file: %s",
1835
                     xstrerror (errno));
1836
 
1837
      t = fscanf (resolution, "%u", &num_objects);
1838
      gcc_assert (t == 1);
1839
 
1840
      /* True, since the plugin splits the archives.  */
1841
      gcc_assert (num_objects == nfiles);
1842
    }
1843
 
1844
  /* Read all of the object files specified on the command line.  */
1845
  for (i = 0, last_file_ix = 0; i < nfiles; ++i)
1846
    {
1847
      struct lto_file_decl_data *file_data = NULL;
1848
 
1849
      current_lto_file = lto_obj_file_open (fnames[i], false);
1850
      if (!current_lto_file)
1851
        break;
1852
 
1853
      file_data = lto_file_read (current_lto_file, resolution);
1854
      if (!file_data)
1855
        break;
1856
 
1857
      all_file_decl_data[last_file_ix++] = file_data;
1858
 
1859
      lto_obj_file_close (current_lto_file);
1860
      current_lto_file = NULL;
1861
    }
1862
 
1863
  if (resolution_file_name)
1864
    fclose (resolution);
1865
 
1866
  all_file_decl_data[last_file_ix] = NULL;
1867
 
1868
  /* Set the hooks so that all of the ipa passes can read in their data.  */
1869
  lto_set_in_hooks (all_file_decl_data, get_section_data, free_section_data);
1870
 
1871
  /* Each pass will set the appropriate timer.  */
1872
  timevar_pop (TV_IPA_LTO_DECL_IO);
1873
 
1874
  /* Read the callgraph.  */
1875
  input_cgraph ();
1876
 
1877
  /* Merge global decls.  */
1878
  lto_symtab_merge_decls ();
1879
 
1880
  /* Fixup all decls and types and free the type hash tables.  */
1881
  lto_fixup_decls (all_file_decl_data);
1882
  free_gimple_type_tables ();
1883
 
1884
  /* Read the IPA summary data.  */
1885
  ipa_read_summaries ();
1886
 
1887
  /* Finally merge the cgraph according to the decl merging decisions.  */
1888
  lto_symtab_merge_cgraph_nodes ();
1889
 
1890
  /* Mark cgraph nodes needed in the merged cgraph
1891
     This normally happens in whole-program pass, but for
1892
     ltrans the pass was already run at WPA phase.
1893
 
1894
     FIXME:  This is not valid way to do so; nodes can be needed
1895
     for non-obvious reasons.  We should stream the flags from WPA
1896
     phase. */
1897
  if (flag_ltrans)
1898
    for (node = cgraph_nodes; node; node = node->next)
1899
      {
1900
        if (!node->global.inlined_to
1901
            && cgraph_decide_is_function_needed (node, node->decl))
1902
          cgraph_mark_needed_node (node);
1903
        /* FIXME: ipa_transforms_to_apply holds list of passes that have optimization
1904
           summaries computed and needs to apply changes.  At the moment WHOPR only
1905
           supports inlining, so we can push it here by hand.  In future we need to stream
1906
           this field into ltrans compilation.  */
1907
        if (node->analyzed)
1908
          VEC_safe_push (ipa_opt_pass, heap,
1909
                         node->ipa_transforms_to_apply,
1910
                         (ipa_opt_pass)&pass_ipa_inline);
1911
      }
1912
 
1913
  timevar_push (TV_IPA_LTO_DECL_IO);
1914
 
1915
  /* FIXME lto. This loop needs to be changed to use the pass manager to
1916
     call the ipa passes directly.  */
1917
  if (!errorcount)
1918
    for (i = 0; i < last_file_ix; i++)
1919
      {
1920
        struct lto_file_decl_data *file_data = all_file_decl_data [i];
1921
        lto_materialize_constructors_and_inits (file_data);
1922
      }
1923
 
1924
  /* Indicate that the cgraph is built and ready.  */
1925
  cgraph_function_flags_ready = true;
1926
 
1927
  timevar_pop (TV_IPA_LTO_DECL_IO);
1928
}
1929
 
1930
 
1931
/* Materialize all the bodies for all the nodes in the callgraph.  */
1932
 
1933
static void
1934
materialize_cgraph (void)
1935
{
1936
  tree decl;
1937
  struct cgraph_node *node;
1938
  unsigned i;
1939
  timevar_id_t lto_timer;
1940
 
1941
  /* Now that we have input the cgraph, we need to clear all of the aux
1942
     nodes and read the functions if we are not running in WPA mode.  */
1943
  timevar_push (TV_IPA_LTO_GIMPLE_IO);
1944
 
1945
  for (node = cgraph_nodes; node; node = node->next)
1946
    {
1947
      /* Some cgraph nodes get created on the fly, and they don't need
1948
         to be materialized.  For instance, nodes for nested functions
1949
         where the parent function was not streamed out or builtin
1950
         functions.  Additionally, builtin functions should not be
1951
         materialized and may, in fact, cause confusion because there
1952
         may be a regular function in the file whose assembler name
1953
         matches that of the function.
1954
         See gcc.c-torture/execute/20030125-1.c and
1955
         gcc.c-torture/execute/921215-1.c.  */
1956
      if (node->local.lto_file_data
1957
          && !DECL_IS_BUILTIN (node->decl))
1958
        {
1959
          lto_materialize_function (node);
1960
          lto_stats.num_input_cgraph_nodes++;
1961
        }
1962
    }
1963
 
1964
  timevar_pop (TV_IPA_LTO_GIMPLE_IO);
1965
 
1966
  /* Start the appropriate timer depending on the mode that we are
1967
     operating in.  */
1968
  lto_timer = (flag_wpa) ? TV_WHOPR_WPA
1969
              : (flag_ltrans) ? TV_WHOPR_LTRANS
1970
              : TV_LTO;
1971
  timevar_push (lto_timer);
1972
 
1973
  current_function_decl = NULL;
1974
  set_cfun (NULL);
1975
 
1976
  /* Inform the middle end about the global variables we have seen.  */
1977
  for (i = 0; VEC_iterate (tree, lto_global_var_decls, i, decl); i++)
1978
    rest_of_decl_compilation (decl, 1, 0);
1979
 
1980
  /* Fix up any calls to DECLs that have become not exception throwing.  */
1981
  lto_fixup_nothrow_decls ();
1982
 
1983
  timevar_pop (lto_timer);
1984
}
1985
 
1986
 
1987
/* Perform whole program analysis (WPA) on the callgraph and write out the
1988
   optimization plan.  */
1989
 
1990
static void
1991
do_whole_program_analysis (void)
1992
{
1993
  char **output_files;
1994
  size_t i;
1995
  struct cgraph_node *node;
1996
 
1997
  lto_1_to_1_map ();
1998
 
1999
  /* Note that since we are in WPA mode, materialize_cgraph will not
2000
     actually read in all the function bodies.  It only materializes
2001
     the decls and cgraph nodes so that analysis can be performed.  */
2002
  materialize_cgraph ();
2003
 
2004
  /* Reading in the cgraph uses different timers, start timing WPA now.  */
2005
  timevar_push (TV_WHOPR_WPA);
2006
 
2007
  /* FIXME lto. Hack. We should use the IPA passes.  There are a
2008
     number of issues with this now. 1. There is no convenient way to
2009
     do this. 2. Some passes may depend on properties that requires
2010
     the function bodies to compute.  */
2011
  cgraph_function_flags_ready = true;
2012
  bitmap_obstack_initialize (NULL);
2013
  ipa_register_cgraph_hooks ();
2014
 
2015
  /* Reset inlining information before running IPA inliner.  */
2016
  for (node = cgraph_nodes; node; node = node->next)
2017
    reset_inline_failed (node);
2018
 
2019
  /* FIXME lto.  We should not call this function directly. */
2020
  pass_ipa_inline.pass.execute ();
2021
 
2022
  verify_cgraph ();
2023
  bitmap_obstack_release (NULL);
2024
 
2025
  /* We are about to launch the final LTRANS phase, stop the WPA timer.  */
2026
  timevar_pop (TV_WHOPR_WPA);
2027
 
2028
  output_files = lto_wpa_write_files ();
2029
 
2030
  /* Show the LTO report before launching LTRANS.  */
2031
  if (flag_lto_report)
2032
    print_lto_report ();
2033
 
2034
  lto_execute_ltrans (output_files);
2035
 
2036
  for (i = 0; output_files[i]; ++i)
2037
    {
2038
      if (output_files[i][0] != '*')
2039
        lto_maybe_unlink (output_files[i]);
2040
 
2041
      free (output_files[i]);
2042
    }
2043
 
2044
  XDELETEVEC (output_files);
2045
}
2046
 
2047
 
2048
/* Main entry point for the GIMPLE front end.  This front end has
2049
   three main personalities:
2050
 
2051
   - LTO (-flto).  All the object files on the command line are
2052
     loaded in memory and processed as a single translation unit.
2053
     This is the traditional link-time optimization behavior.
2054
 
2055
   - WPA (-fwpa).  Only the callgraph and summary information for
2056
     files in the command file are loaded.  A single callgraph
2057
     (without function bodies) is instantiated for the whole set of
2058
     files.  IPA passes are only allowed to analyze the call graph
2059
     and make transformation decisions.  The callgraph is
2060
     partitioned, each partition is written to a new object file
2061
     together with the transformation decisions.
2062
 
2063
   - LTRANS (-fltrans).  Similar to -flto but it prevents the IPA
2064
     summary files from running again.  Since WPA computed summary
2065
     information and decided what transformations to apply, LTRANS
2066
     simply applies them.  */
2067
 
2068
void
2069
lto_main (int debug_p ATTRIBUTE_UNUSED)
2070
{
2071
  lto_init_reader ();
2072
 
2073
  /* Read all the symbols and call graph from all the files in the
2074
     command line.  */
2075
  read_cgraph_and_symbols (num_in_fnames, in_fnames);
2076
 
2077
  if (!errorcount)
2078
    {
2079
      /* If WPA is enabled analyze the whole call graph and create an
2080
         optimization plan.  Otherwise, read in all the function
2081
         bodies and continue with optimization.  */
2082
      if (flag_wpa)
2083
        do_whole_program_analysis ();
2084
      else
2085
        {
2086
          materialize_cgraph ();
2087
 
2088
          /* Let the middle end know that we have read and merged all of
2089
             the input files.  */
2090
          cgraph_optimize ();
2091
 
2092
          /* FIXME lto, if the processes spawned by WPA fail, we miss
2093
             the chance to print WPA's report, so WPA will call
2094
             print_lto_report before launching LTRANS.  If LTRANS was
2095
             launched directly by the driver we would not need to do
2096
             this.  */
2097
          if (flag_lto_report)
2098
            print_lto_report ();
2099
        }
2100
    }
2101
}
2102
 
2103
#include "gt-lto-lto.h"

powered by: WebSVN 2.1.0

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