OSDN Git Service

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