OSDN Git Service

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