OSDN Git Service

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