OSDN Git Service

* cgraph.c (cgraph_create_virtual_clone): Only check
[pf3gnuchains/gcc-fork.git] / gcc / lto / lto.c
1 /* 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
88   /* Ignore clone nodes.  Read the body only from the original one.
89      We may find clone nodes during LTRANS after WPA has made inlining
90      decisions.  */
91   if (node->clone_of)
92     return;
93
94   decl = node->decl;
95   file_data = node->local.lto_file_data;
96   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); 
97
98   /* We may have renamed the declaration, e.g., a static function.  */
99   name = lto_get_decl_name_mapping (file_data, name);
100
101   data = lto_get_section_data (file_data, LTO_section_function_body,
102                                name, &len);
103   if (data)
104     {
105       gcc_assert (!DECL_IS_BUILTIN (decl));
106
107       /* This function has a definition.  */
108       TREE_STATIC (decl) = 1;
109
110       gcc_assert (DECL_STRUCT_FUNCTION (decl) == NULL);
111
112       /* Load the function body only if not operating in WPA mode.  In
113          WPA mode, the body of the function is not needed.  */
114       if (!flag_wpa)
115         {
116          allocate_struct_function (decl, false);
117           announce_function (node->decl);
118           lto_input_function_body (file_data, decl, data);
119           lto_stats.num_function_bodies++;
120         }
121
122       lto_free_section_data (file_data, LTO_section_function_body, name,
123                              data, len);
124       if (!flag_wpa)
125         ggc_collect ();
126     }
127   else
128     DECL_EXTERNAL (decl) = 1;
129
130   /* Let the middle end know about the function.  */
131   rest_of_decl_compilation (decl, 1, 0);
132 }
133
134
135 /* Decode the content of memory pointed to by DATA in the the
136    in decl state object STATE. DATA_IN points to a data_in structure for
137    decoding. Return the address after the decoded object in the input.  */
138
139 static const uint32_t *
140 lto_read_in_decl_state (struct data_in *data_in, const uint32_t *data,
141                         struct lto_in_decl_state *state)
142 {
143   uint32_t ix;
144   tree decl;
145   uint32_t i, j;
146   
147   ix = *data++;
148   decl = lto_streamer_cache_get (data_in->reader_cache, (int) ix);
149   if (TREE_CODE (decl) != FUNCTION_DECL)
150     {
151       gcc_assert (decl == void_type_node);
152       decl = NULL_TREE;
153     }
154   state->fn_decl = decl;
155
156   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
157     {
158       uint32_t size = *data++;
159       tree *decls = GGC_NEWVEC (tree, size);
160
161       for (j = 0; j < size; j++)
162         {
163           decls[j] = lto_streamer_cache_get (data_in->reader_cache, data[j]);
164
165           /* Register every type in the global type table.  If the
166              type existed already, use the existing type.  */
167           if (TYPE_P (decls[j]))
168             decls[j] = gimple_register_type (decls[j]);
169         }
170
171       state->streams[i].size = size;
172       state->streams[i].trees = decls;
173       data += size;
174     }
175
176   return data;
177 }
178
179
180 /* Read all the symbols from buffer DATA, using descriptors in DECL_DATA.
181    RESOLUTIONS is the set of symbols picked by the linker (read from the
182    resolution file when the linker plugin is being used).  */
183
184 static void
185 lto_read_decls (struct lto_file_decl_data *decl_data, const void *data,
186                 VEC(ld_plugin_symbol_resolution_t,heap) *resolutions)
187 {
188   const struct lto_decl_header *header = (const struct lto_decl_header *) data;
189   const int32_t decl_offset = sizeof (struct lto_decl_header);
190   const int32_t main_offset = decl_offset + header->decl_state_size;
191   const int32_t string_offset = main_offset + header->main_size;
192   struct lto_input_block ib_main;
193   struct data_in *data_in;
194   unsigned int i;
195   const uint32_t *data_ptr, *data_end;
196   uint32_t num_decl_states;
197
198   LTO_INIT_INPUT_BLOCK (ib_main, (const char *) data + main_offset, 0,
199                         header->main_size);
200
201   data_in = lto_data_in_create (decl_data, (const char *) data + string_offset,
202                                 header->string_size, resolutions);
203
204   /* Read the global declarations and types.  */
205   while (ib_main.p < ib_main.len)
206     {
207       tree t = lto_input_tree (&ib_main, data_in);
208       gcc_assert (t && ib_main.p <= ib_main.len);
209     }
210
211   /* Read in lto_in_decl_state objects.  */
212   data_ptr = (const uint32_t *) ((const char*) data + decl_offset); 
213   data_end =
214      (const uint32_t *) ((const char*) data_ptr + header->decl_state_size);
215   num_decl_states = *data_ptr++;
216   
217   gcc_assert (num_decl_states > 0);
218   decl_data->global_decl_state = lto_new_in_decl_state ();
219   data_ptr = lto_read_in_decl_state (data_in, data_ptr,
220                                      decl_data->global_decl_state);
221
222   /* Read in per-function decl states and enter them in hash table.  */
223   decl_data->function_decl_states =
224     htab_create_ggc (37, lto_hash_in_decl_state, lto_eq_in_decl_state, NULL);
225
226   for (i = 1; i < num_decl_states; i++)
227     {
228       struct lto_in_decl_state *state = lto_new_in_decl_state ();
229       void **slot;
230
231       data_ptr = lto_read_in_decl_state (data_in, data_ptr, state);
232       slot = htab_find_slot (decl_data->function_decl_states, state, INSERT);
233       gcc_assert (*slot == NULL);
234       *slot = state;
235     }
236
237   if (data_ptr != data_end)
238     internal_error ("bytecode stream: garbage at the end of symbols section");
239   
240   /* Set the current decl state to be the global state. */
241   decl_data->current_decl_state = decl_data->global_decl_state;
242
243   lto_data_in_delete (data_in);
244 }
245
246 /* strtoll is not portable. */
247 int64_t
248 lto_parse_hex (const char *p) {
249   uint64_t ret = 0;
250   for (; *p != '\0'; ++p)
251     {
252       char c = *p;
253       unsigned char part;
254       ret <<= 4;
255       if (c >= '0' && c <= '9')
256         part = c - '0';
257       else if (c >= 'a' && c <= 'f')
258         part = c - 'a' + 10;
259       else if (c >= 'A' && c <= 'F')
260         part = c - 'A' + 10;
261       else
262         internal_error ("could not parse hex number");
263       ret |= part;
264     }
265   return ret;
266 }
267
268 /* Read resolution for file named FILE_NAME. The resolution is read from
269    RESOLUTION. An array with the symbol resolution is returned. The array
270    size is written to SIZE. */
271
272 static VEC(ld_plugin_symbol_resolution_t,heap) *
273 lto_resolution_read (FILE *resolution, lto_file *file)
274 {
275   /* We require that objects in the resolution file are in the same
276      order as the lto1 command line. */
277   unsigned int name_len;
278   char *obj_name;
279   unsigned int num_symbols;
280   unsigned int i;
281   VEC(ld_plugin_symbol_resolution_t,heap) *ret = NULL;
282   unsigned max_index = 0;
283
284   if (!resolution)
285     return NULL;
286
287   name_len = strlen (file->filename);
288   obj_name = XNEWVEC (char, name_len + 1);
289   fscanf (resolution, " ");   /* Read white space. */
290
291   fread (obj_name, sizeof (char), name_len, resolution);
292   obj_name[name_len] = '\0';
293   if (strcmp (obj_name, file->filename) != 0)
294     internal_error ("unexpected file name %s in linker resolution file. "
295                     "Expected %s", obj_name, file->filename);
296   if (file->offset != 0)
297     {
298       int t;
299       char offset_p[17];
300       int64_t offset;
301       t = fscanf (resolution, "@0x%16s", offset_p);
302       if (t != 1)
303         internal_error ("could not parse file offset");
304       offset = lto_parse_hex (offset_p);
305       if (offset != file->offset)
306         internal_error ("unexpected offset");
307     }
308
309   free (obj_name);
310
311   fscanf (resolution, "%u", &num_symbols);
312
313   for (i = 0; i < num_symbols; i++)
314     {
315       int t;
316       unsigned index;
317       char r_str[27];
318       enum ld_plugin_symbol_resolution r;
319       unsigned int j;
320       unsigned int lto_resolution_str_len =
321         sizeof (lto_resolution_str) / sizeof (char *);
322
323       t = fscanf (resolution, "%u %26s %*[^\n]\n", &index, r_str);
324       if (t != 2)
325         internal_error ("Invalid line in the resolution file.");
326       if (index > max_index)
327         max_index = index;
328
329       for (j = 0; j < lto_resolution_str_len; j++)
330         {
331           if (strcmp (lto_resolution_str[j], r_str) == 0)
332             {
333               r = (enum ld_plugin_symbol_resolution) j;
334               break;
335             }
336         }
337       if (j == lto_resolution_str_len)
338         internal_error ("Invalid resolution in the resolution file.");
339
340       VEC_safe_grow_cleared (ld_plugin_symbol_resolution_t, heap, ret,
341                              max_index + 1);
342       VEC_replace (ld_plugin_symbol_resolution_t, ret, index, r);
343     }
344
345   return ret;
346 }
347
348 /* Generate a TREE representation for all types and external decls
349    entities in FILE.  
350
351    Read all of the globals out of the file.  Then read the cgraph
352    and process the .o index into the cgraph nodes so that it can open
353    the .o file to load the functions and ipa information.   */
354
355 static struct lto_file_decl_data *
356 lto_file_read (lto_file *file, FILE *resolution_file)
357 {
358   struct lto_file_decl_data *file_data;
359   const char *data;
360   size_t len;
361   VEC(ld_plugin_symbol_resolution_t,heap) *resolutions;
362   
363   resolutions = lto_resolution_read (resolution_file, file);
364
365   file_data = GGC_NEW (struct lto_file_decl_data);
366   file_data->file_name = file->filename;
367   file_data->section_hash_table = lto_obj_build_section_table (file);
368   file_data->renaming_hash_table = lto_create_renaming_table ();
369
370   data = lto_get_section_data (file_data, LTO_section_decls, NULL, &len);
371   lto_read_decls (file_data, data, resolutions);
372   lto_free_section_data (file_data, LTO_section_decls, NULL, data, len);
373
374   return file_data;
375 }
376
377 #if HAVE_MMAP_FILE && HAVE_SYSCONF && defined _SC_PAGE_SIZE
378 #define LTO_MMAP_IO 1
379 #endif
380
381 #if LTO_MMAP_IO
382 /* Page size of machine is used for mmap and munmap calls.  */
383 static size_t page_mask;
384 #endif
385
386 /* Get the section data of length LEN from FILENAME starting at
387    OFFSET.  The data segment must be freed by the caller when the
388    caller is finished.  Returns NULL if all was not well.  */
389
390 static char *
391 lto_read_section_data (struct lto_file_decl_data *file_data,
392                        intptr_t offset, size_t len)
393 {
394   char *result;
395   static int fd = -1;
396   static char *fd_name;
397 #if LTO_MMAP_IO
398   intptr_t computed_len;
399   intptr_t computed_offset;
400   intptr_t diff;
401 #endif
402
403   /* Keep a single-entry file-descriptor cache.  The last file we
404      touched will get closed at exit.
405      ???  Eventually we want to add a more sophisticated larger cache
406      or rather fix function body streaming to not stream them in
407      practically random order.  */
408   if (fd != -1
409       && strcmp (fd_name, file_data->file_name) != 0)
410     {
411       free (fd_name);
412       close (fd);
413       fd = -1;
414     }
415   if (fd == -1)
416     {
417       fd_name = xstrdup (file_data->file_name);
418       fd = open (file_data->file_name, O_RDONLY|O_BINARY);
419       if (fd == -1)
420         return NULL;
421     }
422
423 #if LTO_MMAP_IO
424   if (!page_mask)
425     {
426       size_t page_size = sysconf (_SC_PAGE_SIZE);
427       page_mask = ~(page_size - 1);
428     }
429
430   computed_offset = offset & page_mask;
431   diff = offset - computed_offset;
432   computed_len = len + diff;
433
434   result = (char *) mmap (NULL, computed_len, PROT_READ, MAP_PRIVATE,
435                           fd, computed_offset);
436   if (result == MAP_FAILED)
437     return NULL;
438
439   return result + diff;
440 #else
441   result = (char *) xmalloc (len);
442   if (lseek (fd, offset, SEEK_SET) != offset
443       || read (fd, result, len) != (ssize_t) len)
444     {
445       free (result);
446       return NULL;
447     }
448
449   return result;
450 #endif
451 }    
452
453
454 /* Get the section data from FILE_DATA of SECTION_TYPE with NAME.
455    NAME will be NULL unless the section type is for a function
456    body.  */
457
458 static const char *
459 get_section_data (struct lto_file_decl_data *file_data,
460                       enum lto_section_type section_type,
461                       const char *name,
462                       size_t *len)
463 {
464   htab_t section_hash_table = file_data->section_hash_table;
465   struct lto_section_slot *f_slot;
466   struct lto_section_slot s_slot;
467   const char *section_name = lto_get_section_name (section_type, name);
468   char *data = NULL;
469
470   *len = 0;
471   s_slot.name = section_name;
472   f_slot = (struct lto_section_slot *) htab_find (section_hash_table, &s_slot);
473   if (f_slot)
474     {
475       data = lto_read_section_data (file_data, f_slot->start, f_slot->len);
476       *len = f_slot->len;
477     }
478
479   free (CONST_CAST (char *, section_name));
480   return data;
481 }
482
483
484 /* Free the section data from FILE_DATA of SECTION_TYPE with NAME that
485    starts at OFFSET and has LEN bytes.  */
486
487 static void
488 free_section_data (struct lto_file_decl_data *file_data ATTRIBUTE_UNUSED,
489                    enum lto_section_type section_type ATTRIBUTE_UNUSED,
490                    const char *name ATTRIBUTE_UNUSED,
491                    const char *offset, size_t len ATTRIBUTE_UNUSED)
492 {
493 #if LTO_MMAP_IO
494   intptr_t computed_len;
495   intptr_t computed_offset;
496   intptr_t diff;
497 #endif
498
499 #if LTO_MMAP_IO
500   computed_offset = ((intptr_t) offset) & page_mask;
501   diff = (intptr_t) offset - computed_offset;
502   computed_len = len + diff;
503
504   munmap ((caddr_t) computed_offset, computed_len);
505 #else
506   free (CONST_CAST(char *, offset));
507 #endif
508 }
509
510 /* Vector of all cgraph node sets. */
511 static GTY (()) VEC(cgraph_node_set, gc) *lto_cgraph_node_sets;
512 static GTY (()) VEC(varpool_node_set, gc) *lto_varpool_node_sets;
513
514
515 /* Group cgrah nodes by input files.  This is used mainly for testing
516    right now.  */
517
518 static void
519 lto_1_to_1_map (void)
520 {
521   struct cgraph_node *node;
522   struct varpool_node *vnode;
523   struct lto_file_decl_data *file_data;
524   struct pointer_map_t *pmap;
525   struct pointer_map_t *vpmap;
526   cgraph_node_set set;
527   varpool_node_set vset;
528   void **slot;
529
530   timevar_push (TV_WHOPR_WPA);
531
532   lto_cgraph_node_sets = VEC_alloc (cgraph_node_set, gc, 1);
533   lto_varpool_node_sets = VEC_alloc (varpool_node_set, gc, 1);
534
535   pmap = pointer_map_create ();
536   vpmap = pointer_map_create ();
537
538   for (node = cgraph_nodes; node; node = node->next)
539     {
540       /* We will get proper partition based on function they are inlined to.  */
541       if (node->global.inlined_to)
542         continue;
543       /* Nodes without a body do not need partitioning.  */
544       if (!node->analyzed)
545         continue;
546
547       file_data = node->local.lto_file_data;
548       gcc_assert (!node->same_body_alias && file_data);
549
550       slot = pointer_map_contains (pmap, file_data);
551       if (slot)
552         set = (cgraph_node_set) *slot;
553       else
554         {
555           set = cgraph_node_set_new ();
556           slot = pointer_map_insert (pmap, file_data);
557           *slot = set;
558           VEC_safe_push (cgraph_node_set, gc, lto_cgraph_node_sets, set);
559           vset = varpool_node_set_new ();
560           slot = pointer_map_insert (vpmap, file_data);
561           *slot = vset;
562           VEC_safe_push (varpool_node_set, gc, lto_varpool_node_sets, vset);
563         }
564
565       cgraph_node_set_add (set, node);
566     }
567
568   for (vnode = varpool_nodes; vnode; vnode = vnode->next)
569     {
570       if (vnode->alias || !vnode->needed)
571         continue;
572       slot = pointer_map_contains (vpmap, file_data);
573       if (slot)
574         vset = (varpool_node_set) *slot;
575       else
576         {
577           set = cgraph_node_set_new ();
578           slot = pointer_map_insert (pmap, file_data);
579           *slot = set;
580           VEC_safe_push (cgraph_node_set, gc, lto_cgraph_node_sets, set);
581           vset = varpool_node_set_new ();
582           slot = pointer_map_insert (vpmap, file_data);
583           *slot = vset;
584           VEC_safe_push (varpool_node_set, gc, lto_varpool_node_sets, vset);
585         }
586
587       varpool_node_set_add (vset, vnode);
588     }
589
590   /* If the cgraph is empty, create one cgraph node set so that there is still
591      an output file for any variables that need to be exported in a DSO.  */
592   if (!lto_cgraph_node_sets)
593     {
594       set = cgraph_node_set_new ();
595       VEC_safe_push (cgraph_node_set, gc, lto_cgraph_node_sets, set);
596       vset = varpool_node_set_new ();
597       VEC_safe_push (varpool_node_set, gc, lto_varpool_node_sets, vset);
598     }
599
600   pointer_map_destroy (pmap);
601   pointer_map_destroy (vpmap);
602
603   timevar_pop (TV_WHOPR_WPA);
604
605   lto_stats.num_cgraph_partitions += VEC_length (cgraph_node_set, 
606                                                  lto_cgraph_node_sets);
607 }
608
609
610 /* Add inlined clone NODE and its master clone to SET, if NODE itself has
611    inlined callees, recursively add the callees.  */
612
613 static void
614 lto_add_inline_clones (cgraph_node_set set, struct cgraph_node *node,
615                        bitmap original_decls)
616 {
617    struct cgraph_node *callee;
618    struct cgraph_edge *edge;
619
620    cgraph_node_set_add (set, node);
621
622    /* Check to see if NODE has any inlined callee.  */
623    for (edge = node->callees; edge != NULL; edge = edge->next_callee)
624      {
625         callee = edge->callee;
626         if (callee->global.inlined_to != NULL)
627           lto_add_inline_clones (set, callee, original_decls);
628      }
629 }
630
631 /* Compute the transitive closure of inlining of SET based on the
632    information in the callgraph.  Returns a bitmap of decls that have
633    been inlined into SET indexed by UID.  */
634
635 static void
636 lto_add_all_inlinees (cgraph_node_set set)
637 {
638   cgraph_node_set_iterator csi;
639   struct cgraph_node *node;
640   bitmap original_nodes = lto_bitmap_alloc ();
641   bitmap original_decls = lto_bitmap_alloc ();
642   bool changed;
643
644   /* We are going to iterate SET while adding to it, mark all original
645      nodes so that we only add node inlined to original nodes.  */
646   for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
647     {
648       bitmap_set_bit (original_nodes, csi_node (csi)->uid);
649       bitmap_set_bit (original_decls, DECL_UID (csi_node (csi)->decl));
650     }
651
652   /* Some of the original nodes might not be needed anymore.  
653      Remove them.  */
654   do
655     {
656       changed = false;
657       for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
658         {
659           struct cgraph_node *inlined_to;
660           node = csi_node (csi);
661
662           /* NODE was not inlined.  We still need it.  */
663           if (!node->global.inlined_to)
664             continue;
665
666           inlined_to = node->global.inlined_to;
667
668           /* NODE should have only one caller.  */
669           gcc_assert (!node->callers->next_caller);
670
671           if (!bitmap_bit_p (original_nodes, inlined_to->uid))
672             {
673               bitmap_clear_bit (original_nodes, node->uid);
674               cgraph_node_set_remove (set, node);
675               changed = true;
676             }
677         }
678     }
679   while (changed);
680
681  /* Transitively add to SET all the inline clones for every node that
682     has been inlined.  */
683  for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
684    {
685      node = csi_node (csi);
686      if (bitmap_bit_p (original_nodes, node->uid))
687       lto_add_inline_clones (set, node, original_decls);
688    }
689
690   lto_bitmap_free (original_nodes);
691   lto_bitmap_free (original_decls);
692 }
693
694 /* Find out all static decls that need to be promoted to global because
695    of cross file sharing.  This function must be run in the WPA mode after
696    all inlinees are added.  */
697
698 static void
699 lto_promote_cross_file_statics (void)
700 {
701   struct varpool_node *vnode;
702   unsigned i, n_sets;
703   cgraph_node_set set;
704   varpool_node_set vset;
705   cgraph_node_set_iterator csi;
706   varpool_node_set_iterator vsi;
707
708   gcc_assert (flag_wpa);
709
710   n_sets = VEC_length (cgraph_node_set, lto_cgraph_node_sets);
711   for (i = 0; i < n_sets; i++)
712     {
713       set = VEC_index (cgraph_node_set, lto_cgraph_node_sets, i);
714       vset = VEC_index (varpool_node_set, lto_varpool_node_sets, i);
715
716       /* If node has either address taken (and we have no clue from where)
717          or it is called from other partition, it needs to be globalized.  */
718       for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
719         {
720           struct cgraph_node *node = csi_node (csi);
721           if (node->local.externally_visible)
722             continue;
723           if (node->global.inlined_to)
724             continue;
725           if (!DECL_EXTERNAL (node->decl)
726               && (referenced_from_other_partition_p (&node->ref_list, set, vset)
727                   || reachable_from_other_partition_p (node, set)))
728              {
729                 gcc_assert (flag_wpa);
730                 TREE_PUBLIC (node->decl) = 1;
731                 DECL_VISIBILITY (node->decl) = VISIBILITY_HIDDEN;
732                 if (node->same_body)
733                   {
734                     struct cgraph_node *alias;
735                     for (alias = node->same_body;
736                          alias; alias = alias->next)
737                       {
738                         TREE_PUBLIC (alias->decl) = 1;
739                         DECL_VISIBILITY (alias->decl) = VISIBILITY_HIDDEN;
740                       }
741                   }
742              }
743         }
744       for (vsi = vsi_start (vset); !vsi_end_p (vsi); vsi_next (&vsi))
745         {
746           vnode = vsi_node (vsi);
747           /* Constant pool references use internal labels and thus can not
748              be made global.  It is sensible to keep those ltrans local to
749              allow better optimization.  */
750           if (!DECL_IN_CONSTANT_POOL (vnode->decl)
751               && !vnode->externally_visible && vnode->analyzed
752               && referenced_from_other_partition_p (&vnode->ref_list, set, vset))
753             {
754               gcc_assert (flag_wpa);
755               TREE_PUBLIC (vnode->decl) = 1;
756               DECL_VISIBILITY (vnode->decl) = VISIBILITY_HIDDEN;
757             }
758         }
759
760     }
761 }
762
763
764 /* Given a file name FNAME, return a string with FNAME prefixed with '*'.  */
765
766 static char *
767 prefix_name_with_star (const char *fname)
768 {
769   char *star_fname;
770   size_t len;
771   
772   len = strlen (fname) + 1 + 1;
773   star_fname = XNEWVEC (char, len);
774   snprintf (star_fname, len, "*%s", fname);
775
776   return star_fname;
777 }
778
779
780 /* Return a copy of FNAME without the .o extension.  */
781
782 static char *
783 strip_extension (const char *fname)
784 {
785   char *s = XNEWVEC (char, strlen (fname) - 2 + 1);
786   gcc_assert (strstr (fname, ".o"));
787   snprintf (s, strlen (fname) - 2 + 1, "%s", fname);
788
789   return s;
790 }
791
792
793 /* Return a file name associated with cgraph node set SET.  This may
794    be a new temporary file name if SET needs to be processed by
795    LTRANS, or the original file name if all the nodes in SET belong to
796    the same input file.  */
797
798 static char *
799 get_filename_for_set (cgraph_node_set set)
800 {
801   char *fname = NULL;
802   static const size_t max_fname_len = 100;
803
804   /* Create a new temporary file to store SET.  To facilitate
805      debugging, use file names from SET as part of the new
806      temporary file name.  */
807   cgraph_node_set_iterator si;
808   struct pointer_set_t *pset = pointer_set_create ();
809   for (si = csi_start (set); !csi_end_p (si); csi_next (&si))
810     {
811       struct cgraph_node *n = csi_node (si);
812       const char *node_fname;
813       char *f;
814
815       /* Don't use the same file name more than once.  */
816       if (pointer_set_insert (pset, n->local.lto_file_data))
817         continue;
818
819       /* The first file name found in SET determines the output
820          directory.  For the remaining files, we use their
821          base names.  */
822       node_fname = n->local.lto_file_data->file_name;
823       if (fname == NULL)
824         {
825           fname = strip_extension (node_fname);
826           continue;
827         }
828
829       f = strip_extension (lbasename (node_fname));
830
831       /* If the new name causes an excessively long file name,
832          make the last component "___" to indicate overflow.  */
833       if (strlen (fname) + strlen (f) > max_fname_len - 3)
834         {
835           fname = reconcat (fname, fname, "___", NULL);
836           break;
837         }
838       else
839         {
840           fname = reconcat (fname, fname, "_", f, NULL);
841           free (f);
842         }
843     }
844
845   pointer_set_destroy (pset);
846
847   if (!fname)
848     {
849       /* Since SET does not need to be processed by LTRANS, use
850          the original file name and mark it with a '*' prefix so that
851          lto_execute_ltrans knows not to process it.  */
852       cgraph_node_set_iterator si = csi_start (set);
853       struct cgraph_node *first = csi_node (si);
854       fname = prefix_name_with_star (first->local.lto_file_data->file_name);
855     }
856   else
857     {
858       /* Add the extension .wpa.o to indicate that this file has been
859          produced by WPA.  */
860       fname = reconcat (fname, fname, ".wpa.o", NULL);
861       gcc_assert (fname);
862     }
863
864   return fname;
865 }
866
867 static lto_file *current_lto_file;
868
869
870 /* Write all output files in WPA mode.  Returns a NULL-terminated array of
871    output file names.  */
872
873 static char **
874 lto_wpa_write_files (void)
875 {
876   char **output_files;
877   unsigned i, n_sets, last_out_file_ix, num_out_files;
878   lto_file *file;
879   cgraph_node_set set;
880   varpool_node_set vset;
881
882   timevar_push (TV_WHOPR_WPA);
883
884   /* Include all inlined functions and determine what sets need to be
885      compiled by LTRANS.  After this loop, only those sets that
886      contain callgraph nodes from more than one file will need to be
887      compiled by LTRANS.  */
888   for (i = 0; VEC_iterate (cgraph_node_set, lto_cgraph_node_sets, i, set); i++)
889     {
890       lto_add_all_inlinees (set);
891       lto_stats.num_output_cgraph_nodes += VEC_length (cgraph_node_ptr,
892                                                        set->nodes);
893     }
894
895   /* After adding all inlinees, find out statics that need to be promoted
896      to globals because of cross-file inlining.  */
897   lto_promote_cross_file_statics ();
898
899   timevar_pop (TV_WHOPR_WPA);
900
901   timevar_push (TV_WHOPR_WPA_IO);
902
903   /* The number of output files depends on the number of input files
904      and how many callgraph node sets we create.  Reserve enough space
905      for the maximum of these two.  */
906   num_out_files = MAX (VEC_length (cgraph_node_set, lto_cgraph_node_sets),
907                        num_in_fnames);
908   output_files = XNEWVEC (char *, num_out_files + 1);
909
910   n_sets = VEC_length (cgraph_node_set, lto_cgraph_node_sets);
911   for (i = 0; i < n_sets; i++)
912     {
913       char *temp_filename;
914
915       set = VEC_index (cgraph_node_set, lto_cgraph_node_sets, i);
916       vset = VEC_index (varpool_node_set, lto_varpool_node_sets, i);
917       temp_filename = get_filename_for_set (set);
918       output_files[i] = temp_filename;
919
920       if (cgraph_node_set_nonempty_p (set) || varpool_node_set_nonempty_p (vset))
921         {
922           /* Write all the nodes in SET to TEMP_FILENAME.  */
923           file = lto_obj_file_open (temp_filename, true);
924           if (!file)
925             fatal_error ("lto_obj_file_open() failed");
926
927           if (!quiet_flag)
928             fprintf (stderr, " %s", temp_filename);
929
930           lto_set_current_out_file (file);
931
932           ipa_write_optimization_summaries (set, vset);
933
934           lto_set_current_out_file (NULL);
935           lto_obj_file_close (file);
936         }
937     }
938
939   last_out_file_ix = n_sets;
940
941   lto_stats.num_output_files += n_sets;
942
943   output_files[last_out_file_ix] = NULL;
944
945   timevar_pop (TV_WHOPR_WPA_IO);
946
947   return output_files;
948 }
949
950 /* Perform local transformations (LTRANS) on the files in the NULL-terminated
951    FILES array.  These should have been written previously by
952    lto_wpa_write_files ().  Transformations are performed via executing
953    COLLECT_GCC for reach file.  */
954
955 static void
956 lto_write_ltrans_list (char *const *files)
957 {
958   FILE *ltrans_output_list_stream = NULL;
959   unsigned i;
960
961   /* Open the LTRANS output list.  */
962   if (!ltrans_output_list)
963     error ("no LTRANS output filename provided");
964
965   ltrans_output_list_stream = fopen (ltrans_output_list, "w");
966   if (ltrans_output_list_stream == NULL)
967     error ("opening LTRANS output list %s: %m", ltrans_output_list);
968
969   for (i = 0; files[i]; ++i)
970     {
971       size_t len;
972
973       len = strlen (files[i]);
974       if (fwrite (files[i], 1, len, ltrans_output_list_stream) < len
975           || fwrite ("\n", 1, 1, ltrans_output_list_stream) < 1)
976         error ("writing to LTRANS output list %s: %m",
977                ltrans_output_list);
978     }
979
980   /* Close the LTRANS output list.  */
981   if (fclose (ltrans_output_list_stream))
982     error ("closing LTRANS output list %s: %m", ltrans_output_list);
983 }
984
985
986 typedef struct {
987   struct pointer_set_t *seen;
988 } lto_fixup_data_t;
989
990 #define LTO_FIXUP_SUBTREE(t) \
991   do \
992     walk_tree (&(t), lto_fixup_tree, data, NULL); \
993   while (0)
994
995 #define LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE(t) \
996   do \
997     { \
998       if (t) \
999         (t) = gimple_register_type (t); \
1000       walk_tree (&(t), lto_fixup_tree, data, NULL); \
1001     } \
1002   while (0)
1003
1004 static tree lto_fixup_tree (tree *, int *, void *);
1005
1006 /* Return true if T does not need to be fixed up recursively.  */
1007
1008 static inline bool
1009 no_fixup_p (tree t)
1010 {
1011   return (t == NULL
1012           || CONSTANT_CLASS_P (t)
1013           || TREE_CODE (t) == IDENTIFIER_NODE);
1014 }
1015
1016 /* Fix up fields of a tree_common T.  DATA points to fix-up states.  */
1017
1018 static void
1019 lto_fixup_common (tree t, void *data)
1020 {
1021   /* The following re-creates the TYPE_REFERENCE_TO and TYPE_POINTER_TO
1022      lists.  We do not stream TYPE_REFERENCE_TO, TYPE_POINTER_TO or
1023      TYPE_NEXT_PTR_TO and TYPE_NEXT_REF_TO.
1024      First remove us from any pointer list we are on.  */
1025   if (TREE_CODE (t) == POINTER_TYPE)
1026     {
1027       if (TYPE_POINTER_TO (TREE_TYPE (t)) == t)
1028         TYPE_POINTER_TO (TREE_TYPE (t)) = TYPE_NEXT_PTR_TO (t);
1029       else
1030         {
1031           tree tem = TYPE_POINTER_TO (TREE_TYPE (t));
1032           while (tem && TYPE_NEXT_PTR_TO (tem) != t)
1033             tem = TYPE_NEXT_PTR_TO (tem);
1034           if (tem)
1035             TYPE_NEXT_PTR_TO (tem) = TYPE_NEXT_PTR_TO (t);
1036         }
1037       TYPE_NEXT_PTR_TO (t) = NULL_TREE;
1038     }
1039   else if (TREE_CODE (t) == REFERENCE_TYPE)
1040     {
1041       if (TYPE_REFERENCE_TO (TREE_TYPE (t)) == t)
1042         TYPE_REFERENCE_TO (TREE_TYPE (t)) = TYPE_NEXT_REF_TO (t);
1043       else
1044         {
1045           tree tem = TYPE_REFERENCE_TO (TREE_TYPE (t));
1046           while (tem && TYPE_NEXT_REF_TO (tem) != t)
1047             tem = TYPE_NEXT_REF_TO (tem);
1048           if (tem)
1049             TYPE_NEXT_REF_TO (tem) = TYPE_NEXT_REF_TO (t);
1050         }
1051       TYPE_NEXT_REF_TO (t) = NULL_TREE;
1052     }
1053
1054   /* Fixup our type.  */
1055   LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TREE_TYPE (t));
1056
1057   /* Second put us on the list of pointers of the new pointed-to type
1058      if we are a main variant.  This is done in lto_fixup_type after
1059      fixing up our main variant.  */
1060
1061   /* This is not very efficient because we cannot do tail-recursion with
1062      a long chain of trees. */
1063   LTO_FIXUP_SUBTREE (TREE_CHAIN (t));
1064 }
1065
1066 /* Fix up fields of a decl_minimal T.  DATA points to fix-up states.  */
1067
1068 static void
1069 lto_fixup_decl_minimal (tree t, void *data)
1070 {
1071   lto_fixup_common (t, data);
1072   LTO_FIXUP_SUBTREE (DECL_NAME (t));
1073   LTO_FIXUP_SUBTREE (DECL_CONTEXT (t));
1074 }
1075
1076 /* Fix up fields of a decl_common T.  DATA points to fix-up states.  */
1077
1078 static void
1079 lto_fixup_decl_common (tree t, void *data)
1080 {
1081   lto_fixup_decl_minimal (t, data);
1082   LTO_FIXUP_SUBTREE (DECL_SIZE (t));
1083   LTO_FIXUP_SUBTREE (DECL_SIZE_UNIT (t));
1084   LTO_FIXUP_SUBTREE (DECL_INITIAL (t));
1085   LTO_FIXUP_SUBTREE (DECL_ATTRIBUTES (t));
1086   LTO_FIXUP_SUBTREE (DECL_ABSTRACT_ORIGIN (t));
1087 }
1088
1089 /* Fix up fields of a decl_with_vis T.  DATA points to fix-up states.  */
1090
1091 static void
1092 lto_fixup_decl_with_vis (tree t, void *data)
1093 {
1094   lto_fixup_decl_common (t, data);
1095
1096   /* Accessor macro has side-effects, use field-name here. */
1097   LTO_FIXUP_SUBTREE (t->decl_with_vis.assembler_name);
1098
1099   gcc_assert (no_fixup_p (DECL_SECTION_NAME (t)));
1100 }
1101
1102 /* Fix up fields of a decl_non_common T.  DATA points to fix-up states.  */
1103
1104 static void
1105 lto_fixup_decl_non_common (tree t, void *data)
1106 {
1107   lto_fixup_decl_with_vis (t, data);
1108   LTO_FIXUP_SUBTREE (DECL_ARGUMENT_FLD (t));
1109   LTO_FIXUP_SUBTREE (DECL_RESULT_FLD (t));
1110   LTO_FIXUP_SUBTREE (DECL_VINDEX (t));
1111
1112   /* SAVED_TREE should not cleared by now.  Also no accessor for base type. */
1113   gcc_assert (no_fixup_p (t->decl_non_common.saved_tree));
1114 }
1115
1116 /* Fix up fields of a decl_non_common T.  DATA points to fix-up states.  */
1117
1118 static void
1119 lto_fixup_function (tree t, void *data)
1120 {
1121   lto_fixup_decl_non_common (t, data);
1122   LTO_FIXUP_SUBTREE (DECL_FUNCTION_PERSONALITY (t));
1123 }
1124
1125 /* Fix up fields of a field_decl T.  DATA points to fix-up states.  */
1126
1127 static void
1128 lto_fixup_field_decl (tree t, void *data)
1129 {
1130   lto_fixup_decl_common (t, data);
1131   LTO_FIXUP_SUBTREE (DECL_FIELD_OFFSET (t));
1132   LTO_FIXUP_SUBTREE (DECL_BIT_FIELD_TYPE (t));
1133   LTO_FIXUP_SUBTREE (DECL_QUALIFIER (t));
1134   gcc_assert (no_fixup_p (DECL_FIELD_BIT_OFFSET (t)));
1135   LTO_FIXUP_SUBTREE (DECL_FCONTEXT (t));
1136 }
1137
1138 /* Fix up fields of a type T.  DATA points to fix-up states.  */
1139
1140 static void
1141 lto_fixup_type (tree t, void *data)
1142 {
1143   tree tem, mv;
1144
1145   lto_fixup_common (t, data);
1146   LTO_FIXUP_SUBTREE (TYPE_CACHED_VALUES (t));
1147   LTO_FIXUP_SUBTREE (TYPE_SIZE (t));
1148   LTO_FIXUP_SUBTREE (TYPE_SIZE_UNIT (t));
1149   LTO_FIXUP_SUBTREE (TYPE_ATTRIBUTES (t));
1150   LTO_FIXUP_SUBTREE (TYPE_NAME (t));
1151
1152   /* Accessors are for derived node types only. */
1153   if (!POINTER_TYPE_P (t))
1154     LTO_FIXUP_SUBTREE (t->type.minval);
1155   LTO_FIXUP_SUBTREE (t->type.maxval);
1156
1157   /* Accessor is for derived node types only. */
1158   LTO_FIXUP_SUBTREE (t->type.binfo);
1159
1160   if (TYPE_CONTEXT (t))
1161     {
1162       if (TYPE_P (TYPE_CONTEXT (t)))
1163         LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TYPE_CONTEXT (t));
1164       else
1165         LTO_FIXUP_SUBTREE (TYPE_CONTEXT (t));
1166     }
1167   LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TYPE_CANONICAL (t));
1168
1169   /* The following re-creates proper variant lists while fixing up
1170      the variant leaders.  We do not stream TYPE_NEXT_VARIANT so the
1171      variant list state before fixup is broken.  */
1172
1173   /* Remove us from our main variant list if we are not the variant leader.  */
1174   if (TYPE_MAIN_VARIANT (t) != t)
1175     {
1176       tem = TYPE_MAIN_VARIANT (t);
1177       while (tem && TYPE_NEXT_VARIANT (tem) != t)
1178         tem = TYPE_NEXT_VARIANT (tem);
1179       if (tem)
1180         TYPE_NEXT_VARIANT (tem) = TYPE_NEXT_VARIANT (t);
1181       TYPE_NEXT_VARIANT (t) = NULL_TREE;
1182     }
1183
1184   /* Query our new main variant.  */
1185   mv = gimple_register_type (TYPE_MAIN_VARIANT (t));
1186
1187   /* If we were the variant leader and we get replaced ourselves drop
1188      all variants from our list.  */
1189   if (TYPE_MAIN_VARIANT (t) == t
1190       && mv != t)
1191     {
1192       tem = t;
1193       while (tem)
1194         {
1195           tree tem2 = TYPE_NEXT_VARIANT (tem);
1196           TYPE_NEXT_VARIANT (tem) = NULL_TREE;
1197           tem = tem2;
1198         }
1199     }
1200
1201   /* If we are not our own variant leader link us into our new leaders
1202      variant list.  */
1203   if (mv != t)
1204     {
1205       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (mv);
1206       TYPE_NEXT_VARIANT (mv) = t;
1207     }
1208
1209   /* Finally adjust our main variant and fix it up.  */
1210   TYPE_MAIN_VARIANT (t) = mv;
1211   LTO_FIXUP_SUBTREE (TYPE_MAIN_VARIANT (t));
1212
1213   /* As the second step of reconstructing the pointer chains put us
1214      on the list of pointers of the new pointed-to type
1215      if we are a main variant.  See lto_fixup_common for the first step.  */
1216   if (TREE_CODE (t) == POINTER_TYPE
1217       && TYPE_MAIN_VARIANT (t) == t)
1218     {
1219       TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (TREE_TYPE (t));
1220       TYPE_POINTER_TO (TREE_TYPE (t)) = t;
1221     }
1222   else if (TREE_CODE (t) == REFERENCE_TYPE
1223            && TYPE_MAIN_VARIANT (t) == t)
1224     {
1225       TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (TREE_TYPE (t));
1226       TYPE_REFERENCE_TO (TREE_TYPE (t)) = t;
1227     }
1228 }
1229
1230 /* Fix up fields of a BINFO T.  DATA points to fix-up states.  */
1231
1232 static void
1233 lto_fixup_binfo (tree t, void *data)
1234 {
1235   unsigned HOST_WIDE_INT i, n;
1236   tree base, saved_base;
1237
1238   lto_fixup_common (t, data);
1239   gcc_assert (no_fixup_p (BINFO_OFFSET (t)));
1240   LTO_FIXUP_SUBTREE (BINFO_VTABLE (t));
1241   LTO_FIXUP_SUBTREE (BINFO_VIRTUALS (t));
1242   LTO_FIXUP_SUBTREE (BINFO_VPTR_FIELD (t));
1243   n = VEC_length (tree, BINFO_BASE_ACCESSES (t));
1244   for (i = 0; i < n; i++)
1245     {
1246       saved_base = base = BINFO_BASE_ACCESS (t, i);
1247       LTO_FIXUP_SUBTREE (base);
1248       if (base != saved_base)
1249         VEC_replace (tree, BINFO_BASE_ACCESSES (t), i, base);
1250     }
1251   LTO_FIXUP_SUBTREE (BINFO_INHERITANCE_CHAIN (t));
1252   LTO_FIXUP_SUBTREE (BINFO_SUBVTT_INDEX (t));
1253   LTO_FIXUP_SUBTREE (BINFO_VPTR_INDEX (t));
1254   n = BINFO_N_BASE_BINFOS (t);
1255   for (i = 0; i < n; i++)
1256     {
1257       saved_base = base = BINFO_BASE_BINFO (t, i);
1258       LTO_FIXUP_SUBTREE (base);
1259       if (base != saved_base)
1260         VEC_replace (tree, BINFO_BASE_BINFOS (t), i, base);
1261     }
1262 }
1263
1264 /* Fix up fields of a CONSTRUCTOR T.  DATA points to fix-up states.  */
1265
1266 static void
1267 lto_fixup_constructor (tree t, void *data)
1268 {
1269   unsigned HOST_WIDE_INT idx;
1270   constructor_elt *ce;
1271
1272   LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TREE_TYPE (t));
1273
1274   for (idx = 0;
1275        VEC_iterate(constructor_elt, CONSTRUCTOR_ELTS (t), idx, ce);
1276        idx++)
1277     {
1278       LTO_FIXUP_SUBTREE (ce->index);
1279       LTO_FIXUP_SUBTREE (ce->value);
1280     }
1281 }
1282
1283 /* A walk_tree callback used by lto_fixup_state. TP is the pointer to the
1284    current tree. WALK_SUBTREES indicates if the subtrees will be walked.
1285    DATA is a pointer set to record visited nodes. */
1286
1287 static tree
1288 lto_fixup_tree (tree *tp, int *walk_subtrees, void *data)
1289 {
1290   tree t;
1291   lto_fixup_data_t *fixup_data = (lto_fixup_data_t *) data;
1292   tree prevailing;
1293
1294   t = *tp;
1295   *walk_subtrees = 0;
1296   if (!t || pointer_set_contains (fixup_data->seen, t))
1297     return NULL;
1298
1299   if (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == FUNCTION_DECL)
1300     {
1301       prevailing = lto_symtab_prevailing_decl (t);
1302
1303       if (t != prevailing)
1304         {
1305            /* Also replace t with prevailing defintion.  We don't want to
1306               insert the other defintion in the seen set as we want to
1307               replace all instances of it.  */
1308           *tp = prevailing;
1309           t = prevailing;
1310         }
1311     }
1312   else if (TYPE_P (t))
1313     {
1314       /* Replace t with the prevailing type.  We don't want to insert the
1315          other type in the seen set as we want to replace all instances of it.  */
1316       t = gimple_register_type (t);
1317       *tp = t;
1318     }
1319
1320   if (pointer_set_insert (fixup_data->seen, t))
1321     return NULL;
1322
1323   /* walk_tree does not visit all reachable nodes that need to be fixed up.
1324      Hence we do special processing here for those kind of nodes. */
1325   switch (TREE_CODE (t))
1326     {
1327     case FIELD_DECL:
1328       lto_fixup_field_decl (t, data);
1329       break;
1330
1331     case LABEL_DECL:
1332     case CONST_DECL:
1333     case PARM_DECL:
1334     case RESULT_DECL:
1335     case IMPORTED_DECL:
1336       lto_fixup_decl_common (t, data);
1337       break;
1338
1339     case VAR_DECL:
1340       lto_fixup_decl_with_vis (t, data);
1341       break;    
1342
1343     case TYPE_DECL:
1344       lto_fixup_decl_non_common (t, data);
1345       break;
1346
1347     case FUNCTION_DECL:
1348       lto_fixup_function (t, data);
1349       break;
1350
1351     case TREE_BINFO:
1352       lto_fixup_binfo (t, data);
1353       break;
1354
1355     default:
1356       if (TYPE_P (t))
1357         lto_fixup_type (t, data);
1358       else if (TREE_CODE (t) == CONSTRUCTOR)
1359         lto_fixup_constructor (t, data);
1360       else if (CONSTANT_CLASS_P (t))
1361         LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TREE_TYPE (t));
1362       else if (EXPR_P (t))
1363         {
1364           /* walk_tree only handles TREE_OPERANDs. Do the rest here.  */
1365           lto_fixup_common (t, data);
1366           LTO_FIXUP_SUBTREE (t->exp.block);
1367           *walk_subtrees = 1;
1368         }
1369       else
1370         {
1371           /* Let walk_tree handle sub-trees.  */
1372           *walk_subtrees = 1;
1373         }
1374     }
1375
1376   return NULL;
1377 }
1378
1379 /* Helper function of lto_fixup_decls. Walks the var and fn streams in STATE,
1380    replaces var and function decls with the corresponding prevailing def and
1381    records the old decl in the free-list in DATA. We also record visted nodes
1382    in the seen-set in DATA to avoid multiple visit for nodes that need not
1383    to be replaced.  */
1384
1385 static void
1386 lto_fixup_state (struct lto_in_decl_state *state, lto_fixup_data_t *data)
1387 {
1388   unsigned i, si;
1389   struct lto_tree_ref_table *table;
1390
1391   /* Although we only want to replace FUNCTION_DECLs and VAR_DECLs,
1392      we still need to walk from all DECLs to find the reachable
1393      FUNCTION_DECLs and VAR_DECLs.  */
1394   for (si = 0; si < LTO_N_DECL_STREAMS; si++)
1395     {
1396       table = &state->streams[si];
1397       for (i = 0; i < table->size; i++)
1398         walk_tree (table->trees + i, lto_fixup_tree, data, NULL);
1399     }
1400 }
1401
1402 /* A callback of htab_traverse. Just extract a state from SLOT and the
1403    lto_fixup_data_t object from AUX and calls lto_fixup_state. */
1404
1405 static int
1406 lto_fixup_state_aux (void **slot, void *aux)
1407 {
1408   struct lto_in_decl_state *state = (struct lto_in_decl_state *) *slot;
1409   lto_fixup_state (state, (lto_fixup_data_t *) aux);
1410   return 1;
1411 }
1412
1413 /* Fix the decls from all FILES. Replaces each decl with the corresponding
1414    prevailing one.  */
1415
1416 static void
1417 lto_fixup_decls (struct lto_file_decl_data **files)
1418 {
1419   unsigned int i;
1420   tree decl;
1421   struct pointer_set_t *seen = pointer_set_create ();
1422   lto_fixup_data_t data;
1423
1424   data.seen = seen;
1425   for (i = 0; files[i]; i++)
1426     {
1427       struct lto_file_decl_data *file = files[i];
1428       struct lto_in_decl_state *state = file->global_decl_state;
1429       lto_fixup_state (state, &data);
1430
1431       htab_traverse (file->function_decl_states, lto_fixup_state_aux, &data);
1432     }
1433
1434   for (i = 0; VEC_iterate (tree, lto_global_var_decls, i, decl); i++)
1435     {
1436       tree saved_decl = decl;
1437       walk_tree (&decl, lto_fixup_tree, &data, NULL);
1438       if (decl != saved_decl)
1439         VEC_replace (tree, lto_global_var_decls, i, decl);
1440     }
1441
1442   pointer_set_destroy (seen);
1443 }
1444
1445 /* Read the options saved from each file in the command line.  Called
1446    from lang_hooks.post_options which is called by process_options
1447    right before all the options are used to initialize the compiler.
1448    This assumes that decode_options has already run, so the
1449    num_in_fnames and in_fnames are properly set.
1450
1451    Note that this assumes that all the files had been compiled with
1452    the same options, which is not a good assumption.  In general,
1453    options ought to be read from all the files in the set and merged.
1454    However, it is still unclear what the merge rules should be.  */
1455
1456 void
1457 lto_read_all_file_options (void)
1458 {
1459   size_t i;
1460
1461   /* Clear any file options currently saved.  */
1462   lto_clear_file_options ();
1463
1464   /* Set the hooks to read ELF sections.  */
1465   lto_set_in_hooks (NULL, get_section_data, free_section_data);
1466
1467   for (i = 0; i < num_in_fnames; i++)
1468     {
1469       struct lto_file_decl_data *file_data;
1470       lto_file *file = lto_obj_file_open (in_fnames[i], false);
1471       if (!file)
1472         break;
1473
1474       file_data = XCNEW (struct lto_file_decl_data);
1475       file_data->file_name = file->filename;
1476       file_data->section_hash_table = lto_obj_build_section_table (file);
1477
1478       lto_read_file_options (file_data);
1479
1480       lto_obj_file_close (file);
1481       htab_delete (file_data->section_hash_table);
1482       free (file_data);
1483     }
1484
1485   /* Apply globally the options read from all the files.  */
1486   lto_reissue_options ();
1487 }
1488
1489 static GTY((length ("lto_stats.num_input_files + 1"))) struct lto_file_decl_data **all_file_decl_data;
1490
1491 /* Read all the symbols from the input files FNAMES.  NFILES is the
1492    number of files requested in the command line.  Instantiate a
1493    global call graph by aggregating all the sub-graphs found in each
1494    file.  */
1495
1496 static void
1497 read_cgraph_and_symbols (unsigned nfiles, const char **fnames)
1498 {
1499   unsigned int i, last_file_ix;
1500   FILE *resolution;
1501   struct cgraph_node *node;
1502
1503   lto_stats.num_input_files = nfiles;
1504
1505   timevar_push (TV_IPA_LTO_DECL_IO);
1506
1507   /* Set the hooks so that all of the ipa passes can read in their data.  */
1508   all_file_decl_data = GGC_CNEWVEC (struct lto_file_decl_data *, nfiles + 1);
1509   lto_set_in_hooks (all_file_decl_data, get_section_data, free_section_data);
1510
1511   /* Read the resolution file.  */
1512   resolution = NULL;
1513   if (resolution_file_name)
1514     {
1515       int t;
1516       unsigned num_objects;
1517
1518       resolution = fopen (resolution_file_name, "r");
1519       if (resolution == NULL)
1520         fatal_error ("could not open symbol resolution file: %s",
1521                      xstrerror (errno));
1522
1523       t = fscanf (resolution, "%u", &num_objects);
1524       gcc_assert (t == 1);
1525
1526       /* True, since the plugin splits the archives.  */
1527       gcc_assert (num_objects == nfiles);
1528     }
1529
1530   if (!quiet_flag)
1531     fprintf (stderr, "Reading object files:");
1532
1533   /* Read all of the object files specified on the command line.  */
1534   for (i = 0, last_file_ix = 0; i < nfiles; ++i)
1535     {
1536       struct lto_file_decl_data *file_data = NULL;
1537       if (!quiet_flag)
1538         {
1539           fprintf (stderr, " %s", fnames[i]);
1540           fflush (stderr);
1541         }
1542
1543       current_lto_file = lto_obj_file_open (fnames[i], false);
1544       if (!current_lto_file)
1545         break;
1546
1547       file_data = lto_file_read (current_lto_file, resolution);
1548       if (!file_data)
1549         break;
1550
1551       all_file_decl_data[last_file_ix++] = file_data;
1552
1553       lto_obj_file_close (current_lto_file);
1554       current_lto_file = NULL;
1555       ggc_collect ();
1556     }
1557
1558   if (resolution_file_name)
1559     fclose (resolution);
1560
1561   all_file_decl_data[last_file_ix] = NULL;
1562
1563   /* Set the hooks so that all of the ipa passes can read in their data.  */
1564   lto_set_in_hooks (all_file_decl_data, get_section_data, free_section_data);
1565
1566   timevar_pop (TV_IPA_LTO_DECL_IO);
1567
1568   if (!quiet_flag)
1569     fprintf (stderr, "\nReading the callgraph\n");
1570
1571   timevar_push (TV_IPA_LTO_CGRAPH_IO);
1572   /* Read the callgraph.  */
1573   input_cgraph ();
1574   timevar_pop (TV_IPA_LTO_CGRAPH_IO);
1575
1576   if (!quiet_flag)
1577     fprintf (stderr, "Merging declarations\n");
1578
1579   timevar_push (TV_IPA_LTO_DECL_MERGE);
1580   /* Merge global decls.  */
1581   lto_symtab_merge_decls ();
1582
1583   /* Fixup all decls and types and free the type hash tables.  */
1584   lto_fixup_decls (all_file_decl_data);
1585   free_gimple_type_tables ();
1586   ggc_collect ();
1587
1588   timevar_pop (TV_IPA_LTO_DECL_MERGE);
1589   /* Each pass will set the appropriate timer.  */
1590
1591   if (!quiet_flag)
1592     fprintf (stderr, "Reading summaries\n");
1593
1594   /* Read the IPA summary data.  */
1595   if (flag_ltrans)
1596     ipa_read_optimization_summaries ();
1597   else
1598     ipa_read_summaries ();
1599
1600   /* Finally merge the cgraph according to the decl merging decisions.  */
1601   timevar_push (TV_IPA_LTO_CGRAPH_MERGE);
1602   lto_symtab_merge_cgraph_nodes ();
1603   ggc_collect ();
1604
1605   if (flag_ltrans)
1606     for (node = cgraph_nodes; node; node = node->next)
1607       {
1608         /* FIXME: ipa_transforms_to_apply holds list of passes that have optimization
1609            summaries computed and needs to apply changes.  At the moment WHOPR only
1610            supports inlining, so we can push it here by hand.  In future we need to stream
1611            this field into ltrans compilation.  */
1612         if (node->analyzed)
1613           VEC_safe_push (ipa_opt_pass, heap,
1614                          node->ipa_transforms_to_apply,
1615                          (ipa_opt_pass)&pass_ipa_inline);
1616       }
1617   lto_symtab_free ();
1618
1619   timevar_pop (TV_IPA_LTO_CGRAPH_MERGE);
1620
1621   timevar_push (TV_IPA_LTO_DECL_INIT_IO);
1622
1623   /* FIXME lto. This loop needs to be changed to use the pass manager to
1624      call the ipa passes directly.  */
1625   if (!errorcount)
1626     for (i = 0; i < last_file_ix; i++)
1627       {
1628         struct lto_file_decl_data *file_data = all_file_decl_data [i];
1629         lto_materialize_constructors_and_inits (file_data);
1630       }
1631
1632   /* Indicate that the cgraph is built and ready.  */
1633   cgraph_function_flags_ready = true;
1634
1635   timevar_pop (TV_IPA_LTO_DECL_INIT_IO);
1636   ggc_free (all_file_decl_data);
1637   all_file_decl_data = NULL;
1638 }
1639
1640
1641 /* Materialize all the bodies for all the nodes in the callgraph.  */
1642
1643 static void
1644 materialize_cgraph (void)
1645 {
1646   tree decl;
1647   struct cgraph_node *node; 
1648   unsigned i;
1649   timevar_id_t lto_timer;
1650
1651   if (!quiet_flag)
1652     fprintf (stderr,
1653              flag_wpa ? "Materializing decls:" : "Reading function bodies:");
1654
1655
1656   /* Now that we have input the cgraph, we need to clear all of the aux
1657      nodes and read the functions if we are not running in WPA mode.  */
1658   timevar_push (TV_IPA_LTO_GIMPLE_IO);
1659
1660   for (node = cgraph_nodes; node; node = node->next)
1661     {
1662       /* Some cgraph nodes get created on the fly, and they don't need
1663          to be materialized.  For instance, nodes for nested functions
1664          where the parent function was not streamed out or builtin
1665          functions.  Additionally, builtin functions should not be
1666          materialized and may, in fact, cause confusion because there
1667          may be a regular function in the file whose assembler name
1668          matches that of the function.
1669          See gcc.c-torture/execute/20030125-1.c and
1670          gcc.c-torture/execute/921215-1.c.  */
1671       if (node->local.lto_file_data
1672           && !DECL_IS_BUILTIN (node->decl))
1673         {
1674           lto_materialize_function (node);
1675           lto_stats.num_input_cgraph_nodes++;
1676         }
1677     }
1678
1679   timevar_pop (TV_IPA_LTO_GIMPLE_IO);
1680
1681   /* Start the appropriate timer depending on the mode that we are
1682      operating in.  */
1683   lto_timer = (flag_wpa) ? TV_WHOPR_WPA
1684               : (flag_ltrans) ? TV_WHOPR_LTRANS
1685               : TV_LTO;
1686   timevar_push (lto_timer);
1687
1688   current_function_decl = NULL;
1689   set_cfun (NULL);
1690
1691   /* Inform the middle end about the global variables we have seen.  */
1692   for (i = 0; VEC_iterate (tree, lto_global_var_decls, i, decl); i++)
1693     rest_of_decl_compilation (decl, 1, 0);
1694
1695   if (!quiet_flag)
1696     fprintf (stderr, "\n");
1697
1698   timevar_pop (lto_timer);
1699 }
1700
1701
1702 /* Perform whole program analysis (WPA) on the callgraph and write out the
1703    optimization plan.  */
1704
1705 static void
1706 do_whole_program_analysis (void)
1707 {
1708   char **output_files;
1709
1710   /* Note that since we are in WPA mode, materialize_cgraph will not
1711      actually read in all the function bodies.  It only materializes
1712      the decls and cgraph nodes so that analysis can be performed.  */
1713   materialize_cgraph ();
1714
1715   /* Reading in the cgraph uses different timers, start timing WPA now.  */
1716   timevar_push (TV_WHOPR_WPA);
1717
1718   if (pre_ipa_mem_report)
1719     {
1720       fprintf (stderr, "Memory consumption before IPA\n");
1721       dump_memory_report (false);
1722     }
1723
1724   cgraph_function_flags_ready = true;
1725   bitmap_obstack_initialize (NULL);
1726   ipa_register_cgraph_hooks ();
1727   cgraph_state = CGRAPH_STATE_IPA_SSA;
1728
1729   execute_ipa_pass_list (all_regular_ipa_passes);
1730
1731   verify_cgraph ();
1732   bitmap_obstack_release (NULL);
1733
1734   /* We are about to launch the final LTRANS phase, stop the WPA timer.  */
1735   timevar_pop (TV_WHOPR_WPA);
1736
1737   lto_1_to_1_map ();
1738
1739   if (!quiet_flag)
1740     {
1741       fprintf (stderr, "\nStreaming out");
1742       fflush (stderr);
1743     }
1744   output_files = lto_wpa_write_files ();
1745   ggc_collect ();
1746   if (!quiet_flag)
1747     fprintf (stderr, "\n");
1748
1749   if (post_ipa_mem_report)
1750     {
1751       fprintf (stderr, "Memory consumption after IPA\n");
1752       dump_memory_report (false);
1753     }
1754
1755   /* Show the LTO report before launching LTRANS.  */
1756   if (flag_lto_report)
1757     print_lto_report ();
1758
1759   lto_write_ltrans_list (output_files);
1760
1761   XDELETEVEC (output_files);
1762 }
1763
1764
1765 /* Main entry point for the GIMPLE front end.  This front end has
1766    three main personalities:
1767
1768    - LTO (-flto).  All the object files on the command line are
1769      loaded in memory and processed as a single translation unit.
1770      This is the traditional link-time optimization behavior.
1771
1772    - WPA (-fwpa).  Only the callgraph and summary information for
1773      files in the command file are loaded.  A single callgraph
1774      (without function bodies) is instantiated for the whole set of
1775      files.  IPA passes are only allowed to analyze the call graph
1776      and make transformation decisions.  The callgraph is
1777      partitioned, each partition is written to a new object file
1778      together with the transformation decisions.
1779
1780    - LTRANS (-fltrans).  Similar to -flto but it prevents the IPA
1781      summary files from running again.  Since WPA computed summary
1782      information and decided what transformations to apply, LTRANS
1783      simply applies them.  */
1784
1785 void
1786 lto_main (int debug_p ATTRIBUTE_UNUSED)
1787 {
1788   lto_init_reader ();
1789
1790   /* Read all the symbols and call graph from all the files in the
1791      command line.  */
1792   read_cgraph_and_symbols (num_in_fnames, in_fnames);
1793
1794   if (!errorcount)
1795     {
1796       /* If WPA is enabled analyze the whole call graph and create an
1797          optimization plan.  Otherwise, read in all the function
1798          bodies and continue with optimization.  */
1799       if (flag_wpa)
1800         do_whole_program_analysis ();
1801       else
1802         {
1803           materialize_cgraph ();
1804
1805           /* Let the middle end know that we have read and merged all of
1806              the input files.  */ 
1807           cgraph_optimize ();
1808
1809           /* FIXME lto, if the processes spawned by WPA fail, we miss
1810              the chance to print WPA's report, so WPA will call
1811              print_lto_report before launching LTRANS.  If LTRANS was
1812              launched directly by the driver we would not need to do
1813              this.  */
1814           if (flag_lto_report)
1815             print_lto_report ();
1816         }
1817     }
1818 }
1819
1820 #include "gt-lto-lto.h"