OSDN Git Service

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