OSDN Git Service

* tree-profile.c (tree_init_ic_make_global_vars): Mark new decls as
[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)
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   cgraph_node_set_iterator csi;
722
723   gcc_assert (flag_wpa);
724
725   /* At moment we make no attempt to figure out who is refering the variables,
726      so all must become global.  */
727   for (vnode = varpool_nodes; vnode; vnode = vnode->next)
728     if (!vnode->externally_visible && vnode->analyzed)
729        {
730           TREE_PUBLIC (vnode->decl) = 1;
731           DECL_VISIBILITY (vnode->decl) = VISIBILITY_HIDDEN;
732        }
733   n_sets = VEC_length (cgraph_node_set, lto_cgraph_node_sets);
734   for (i = 0; i < n_sets; i++)
735     {
736       set = VEC_index (cgraph_node_set, lto_cgraph_node_sets, i);
737
738       /* If node has either address taken (and we have no clue from where)
739          or it is called from other partition, it needs to be globalized.  */
740       for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
741         {
742           struct cgraph_node *node = csi_node (csi);
743           bool globalize = node->address_taken || node->local.vtable_method;
744           struct cgraph_edge *e;
745           if (node->local.externally_visible)
746             continue;
747           for (e = node->callers; e && !globalize; e = e->next_caller)
748             {
749               struct cgraph_node *caller = e->caller;
750               if (caller->global.inlined_to)
751                 caller = caller->global.inlined_to;
752               if (!cgraph_node_in_set_p (caller, set))
753                 globalize = true;
754             }
755           if (globalize)
756              {
757                 TREE_PUBLIC (node->decl) = 1;
758                 DECL_VISIBILITY (node->decl) = VISIBILITY_HIDDEN;
759                 if (node->same_body)
760                   {
761                     struct cgraph_node *alias;
762                     for (alias = node->same_body;
763                          alias; alias = alias->next)
764                       {
765                         TREE_PUBLIC (alias->decl) = 1;
766                         DECL_VISIBILITY (alias->decl) = VISIBILITY_HIDDEN;
767                       }
768                   }
769              }
770         }
771
772     }
773 }
774
775
776 /* Given a file name FNAME, return a string with FNAME prefixed with '*'.  */
777
778 static char *
779 prefix_name_with_star (const char *fname)
780 {
781   char *star_fname;
782   size_t len;
783   
784   len = strlen (fname) + 1 + 1;
785   star_fname = XNEWVEC (char, len);
786   snprintf (star_fname, len, "*%s", fname);
787
788   return star_fname;
789 }
790
791
792 /* Return a copy of FNAME without the .o extension.  */
793
794 static char *
795 strip_extension (const char *fname)
796 {
797   char *s = XNEWVEC (char, strlen (fname) - 2 + 1);
798   gcc_assert (strstr (fname, ".o"));
799   snprintf (s, strlen (fname) - 2 + 1, "%s", fname);
800
801   return s;
802 }
803
804
805 /* Return a file name associated with cgraph node set SET.  This may
806    be a new temporary file name if SET needs to be processed by
807    LTRANS, or the original file name if all the nodes in SET belong to
808    the same input file.  */
809
810 static char *
811 get_filename_for_set (cgraph_node_set set)
812 {
813   char *fname = NULL;
814   static const size_t max_fname_len = 100;
815
816   if (cgraph_node_set_needs_ltrans_p (set))
817     {
818       /* Create a new temporary file to store SET.  To facilitate
819          debugging, use file names from SET as part of the new
820          temporary file name.  */
821       cgraph_node_set_iterator si;
822       struct pointer_set_t *pset = pointer_set_create ();
823       for (si = csi_start (set); !csi_end_p (si); csi_next (&si))
824         {
825           struct cgraph_node *n = csi_node (si);
826           const char *node_fname;
827           char *f;
828
829           /* Don't use the same file name more than once.  */
830           if (pointer_set_insert (pset, n->local.lto_file_data))
831             continue;
832
833           /* The first file name found in SET determines the output
834              directory.  For the remaining files, we use their
835              base names.  */
836           node_fname = n->local.lto_file_data->file_name;
837           if (fname == NULL)
838             {
839               fname = strip_extension (node_fname);
840               continue;
841             }
842
843           f = strip_extension (lbasename (node_fname));
844
845           /* If the new name causes an excessively long file name,
846              make the last component "___" to indicate overflow.  */
847           if (strlen (fname) + strlen (f) > max_fname_len - 3)
848             {
849               fname = reconcat (fname, fname, "___", NULL);
850               break;
851             }
852           else
853             {
854               fname = reconcat (fname, fname, "_", f, NULL);
855               free (f);
856             }
857         }
858
859       pointer_set_destroy (pset);
860
861       /* Add the extension .wpa.o to indicate that this file has been
862          produced by WPA.  */
863       fname = reconcat (fname, fname, ".wpa.o", NULL);
864       gcc_assert (fname);
865     }
866   else
867     {
868       /* Since SET does not need to be processed by LTRANS, use
869          the original file name and mark it with a '*' prefix so that
870          lto_execute_ltrans knows not to process it.  */
871       cgraph_node_set_iterator si = csi_start (set);
872       struct cgraph_node *first = csi_node (si);
873       fname = prefix_name_with_star (first->local.lto_file_data->file_name);
874     }
875
876   return fname;
877 }
878
879 static lto_file *current_lto_file;
880
881
882 /* Write all output files in WPA mode.  Returns a NULL-terminated array of
883    output file names.  */
884
885 static char **
886 lto_wpa_write_files (void)
887 {
888   char **output_files;
889   unsigned i, n_sets, last_out_file_ix, num_out_files;
890   lto_file *file;
891   cgraph_node_set set;
892   varpool_node_set vset;
893
894   timevar_push (TV_WHOPR_WPA);
895
896   /* Include all inlined functions and determine what sets need to be
897      compiled by LTRANS.  After this loop, only those sets that
898      contain callgraph nodes from more than one file will need to be
899      compiled by LTRANS.  */
900   for (i = 0; VEC_iterate (cgraph_node_set, lto_cgraph_node_sets, i, set); i++)
901     {
902       lto_add_all_inlinees (set);
903       lto_stats.num_output_cgraph_nodes += VEC_length (cgraph_node_ptr,
904                                                        set->nodes);
905     }
906
907   /* After adding all inlinees, find out statics that need to be promoted
908      to globals because of cross-file inlining.  */
909   lto_promote_cross_file_statics ();
910
911   timevar_pop (TV_WHOPR_WPA);
912
913   timevar_push (TV_WHOPR_WPA_IO);
914
915   /* The number of output files depends on the number of input files
916      and how many callgraph node sets we create.  Reserve enough space
917      for the maximum of these two.  */
918   num_out_files = MAX (VEC_length (cgraph_node_set, lto_cgraph_node_sets),
919                        num_in_fnames);
920   output_files = XNEWVEC (char *, num_out_files + 1);
921
922   n_sets = VEC_length (cgraph_node_set, lto_cgraph_node_sets);
923   for (i = 0; i < n_sets; i++)
924     {
925       char *temp_filename;
926
927       set = VEC_index (cgraph_node_set, lto_cgraph_node_sets, i);
928       vset = VEC_index (varpool_node_set, lto_varpool_node_sets, i);
929       temp_filename = get_filename_for_set (set);
930       output_files[i] = temp_filename;
931
932       if (cgraph_node_set_needs_ltrans_p (set))
933         {
934           /* Write all the nodes in SET to TEMP_FILENAME.  */
935           file = lto_obj_file_open (temp_filename, true);
936           if (!file)
937             fatal_error ("lto_obj_file_open() failed");
938
939           if (!quiet_flag)
940             fprintf (stderr, " %s", temp_filename);
941
942           lto_set_current_out_file (file);
943
944           ipa_write_optimization_summaries (set, vset);
945
946           lto_set_current_out_file (NULL);
947           lto_obj_file_close (file);
948         }
949     }
950
951   last_out_file_ix = n_sets;
952
953   lto_stats.num_output_files += n_sets;
954
955   output_files[last_out_file_ix] = NULL;
956
957   timevar_pop (TV_WHOPR_WPA_IO);
958
959   return output_files;
960 }
961
962 /* Template of LTRANS dumpbase suffix.  */
963 #define DUMPBASE_SUFFIX ".ltrans18446744073709551615"
964
965 /* Perform local transformations (LTRANS) on the files in the NULL-terminated
966    FILES array.  These should have been written previously by
967    lto_wpa_write_files ().  Transformations are performed via executing
968    COLLECT_GCC for reach file.  */
969
970 static void
971 lto_execute_ltrans (char *const *files)
972 {
973   struct pex_obj *pex;
974   const char *collect_gcc_options, *collect_gcc;
975   struct obstack env_obstack;
976   const char **argv;
977   const char **argv_ptr;
978   const char *errmsg;
979   size_t i, j;
980   int err;
981   int status;
982   FILE *ltrans_output_list_stream = NULL;
983   bool seen_dumpbase = false;
984   char *dumpbase_suffix = NULL;
985
986   timevar_push (TV_WHOPR_WPA_LTRANS_EXEC);
987
988   /* Get the driver and options.  */
989   collect_gcc = getenv ("COLLECT_GCC");
990   if (!collect_gcc)
991     fatal_error ("environment variable COLLECT_GCC must be set");
992
993   /* Set the CFLAGS environment variable.  */
994   collect_gcc_options = getenv ("COLLECT_GCC_OPTIONS");
995   if (!collect_gcc_options)
996     fatal_error ("environment variable COLLECT_GCC_OPTIONS must be set");
997
998   /* Count arguments.  */
999   i = 0;
1000   for (j = 0; collect_gcc_options[j] != '\0'; ++j)
1001     if (collect_gcc_options[j] == '\'')
1002       ++i;
1003
1004   if (i % 2 != 0)
1005     fatal_error ("malformed COLLECT_GCC_OPTIONS");
1006
1007   /* Initalize the arguments for the LTRANS driver.  */
1008   argv = XNEWVEC (const char *, 8 + i / 2);
1009   argv_ptr = argv;
1010   *argv_ptr++ = collect_gcc;
1011   *argv_ptr++ = "-xlto";
1012   for (j = 0; collect_gcc_options[j] != '\0'; ++j)
1013     if (collect_gcc_options[j] == '\'')
1014       {
1015         char *option;
1016
1017         ++j;
1018         i = j;
1019         while (collect_gcc_options[j] != '\'')
1020           ++j;
1021         obstack_init (&env_obstack);
1022         obstack_grow (&env_obstack, &collect_gcc_options[i], j - i);
1023         if (seen_dumpbase)
1024           obstack_grow (&env_obstack, DUMPBASE_SUFFIX,
1025                         sizeof (DUMPBASE_SUFFIX));
1026         else
1027           obstack_1grow (&env_obstack, 0);
1028         option = XOBFINISH (&env_obstack, char *);
1029         if (seen_dumpbase)
1030           {
1031             dumpbase_suffix = option + 7 + j - i;
1032             seen_dumpbase = false;
1033           }
1034
1035         /* LTRANS does not need -fwpa nor -fltrans-*.  */
1036         if (strncmp (option, "-fwpa", 5) != 0
1037             && strncmp (option, "-fltrans-", 9) != 0)
1038           {
1039             if (strncmp (option, "-dumpbase", 9) == 0)
1040               seen_dumpbase = true;
1041             *argv_ptr++ = option;
1042           }
1043       }
1044   *argv_ptr++ = "-fltrans";
1045
1046   /* Open the LTRANS output list.  */
1047   if (ltrans_output_list)
1048     {
1049       ltrans_output_list_stream = fopen (ltrans_output_list, "w");
1050       if (ltrans_output_list_stream == NULL)
1051         error ("opening LTRANS output list %s: %m", ltrans_output_list);
1052     }
1053
1054   for (i = 0; files[i]; ++i)
1055     {
1056       size_t len;
1057
1058       /* If the file is prefixed with a '*', it means that we do not
1059          need to re-compile it with LTRANS because it has not been
1060          modified by WPA.  Skip it from the command line to
1061          lto_execute_ltrans, but add it to ltrans_output_list_stream
1062          so it is linked after we are done.  */
1063       if (files[i][0] == '*')
1064         {
1065           size_t len = strlen (files[i]) - 1;
1066           if (ltrans_output_list_stream)
1067             if (fwrite (&files[i][1], 1, len, ltrans_output_list_stream) < len
1068                 || fwrite ("\n", 1, 1, ltrans_output_list_stream) < 1)
1069               error ("writing to LTRANS output list %s: %m",
1070                      ltrans_output_list);
1071         }
1072       else
1073         {
1074           char *output_name;
1075
1076           /* Otherwise, add FILES[I] to lto_execute_ltrans command line
1077              and add the resulting file to LTRANS output list.  */
1078
1079           /* Replace the .o suffix with a .ltrans.o suffix and write
1080              the resulting name to the LTRANS output list.  */
1081           obstack_init (&env_obstack);
1082           obstack_grow (&env_obstack, files[i], strlen (files[i]) - 2);
1083           obstack_grow (&env_obstack, ".ltrans.o", sizeof (".ltrans.o"));
1084           output_name = XOBFINISH (&env_obstack, char *);
1085           if (ltrans_output_list_stream)
1086             {
1087               len = strlen (output_name);
1088
1089               if (fwrite (output_name, 1, len, ltrans_output_list_stream) < len
1090                   || fwrite ("\n", 1, 1, ltrans_output_list_stream) < 1)
1091                 error ("writing to LTRANS output list %s: %m",
1092                        ltrans_output_list);
1093             }
1094
1095           argv_ptr[0] = "-o";
1096           argv_ptr[1] = output_name;
1097           argv_ptr[2] = files[i];
1098           argv_ptr[3] = NULL;
1099
1100           /* Append a sequence number to -dumpbase for LTRANS.  */
1101           if (dumpbase_suffix)
1102             snprintf (dumpbase_suffix, sizeof (DUMPBASE_SUFFIX) - 7,
1103                       "%lu", (unsigned long) i);
1104
1105           /* Execute the driver.  */
1106           pex = pex_init (0, "lto1", NULL);
1107           if (pex == NULL)
1108             fatal_error ("pex_init failed: %s", xstrerror (errno));
1109
1110           errmsg = pex_run (pex, PEX_LAST | PEX_SEARCH, argv[0],
1111                             CONST_CAST (char **, argv), NULL, NULL, &err);
1112           if (errmsg)
1113             fatal_error ("%s: %s", errmsg, xstrerror (err));
1114
1115           if (!pex_get_status (pex, 1, &status))
1116             fatal_error ("can't get program status: %s", xstrerror (errno));
1117
1118           if (status)
1119             {
1120               if (WIFSIGNALED (status))
1121                 {
1122                   int sig = WTERMSIG (status);
1123                   fatal_error ("%s terminated with signal %d [%s]%s",
1124                                argv[0], sig, strsignal (sig),
1125                                WCOREDUMP (status) ? ", core dumped" : "");
1126                 }
1127               else
1128                 fatal_error ("%s terminated with status %d", argv[0], status);
1129             }
1130
1131           pex_free (pex);
1132         }
1133     }
1134
1135   /* Close the LTRANS output list.  */
1136   if (ltrans_output_list_stream && fclose (ltrans_output_list_stream))
1137     error ("closing LTRANS output list %s: %m", ltrans_output_list);
1138
1139   obstack_free (&env_obstack, NULL);
1140   free (argv);
1141
1142   timevar_pop (TV_WHOPR_WPA_LTRANS_EXEC);
1143 }
1144
1145
1146 typedef struct {
1147   struct pointer_set_t *seen;
1148 } lto_fixup_data_t;
1149
1150 #define LTO_FIXUP_SUBTREE(t) \
1151   do \
1152     walk_tree (&(t), lto_fixup_tree, data, NULL); \
1153   while (0)
1154
1155 #define LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE(t) \
1156   do \
1157     { \
1158       if (t) \
1159         (t) = gimple_register_type (t); \
1160       walk_tree (&(t), lto_fixup_tree, data, NULL); \
1161     } \
1162   while (0)
1163
1164 static tree lto_fixup_tree (tree *, int *, void *);
1165
1166 /* Return true if T does not need to be fixed up recursively.  */
1167
1168 static inline bool
1169 no_fixup_p (tree t)
1170 {
1171   return (t == NULL
1172           || CONSTANT_CLASS_P (t)
1173           || TREE_CODE (t) == IDENTIFIER_NODE);
1174 }
1175
1176 /* Fix up fields of a tree_common T.  DATA points to fix-up states.  */
1177
1178 static void
1179 lto_fixup_common (tree t, void *data)
1180 {
1181   /* The following re-creates the TYPE_REFERENCE_TO and TYPE_POINTER_TO
1182      lists.  We do not stream TYPE_REFERENCE_TO, TYPE_POINTER_TO or
1183      TYPE_NEXT_PTR_TO and TYPE_NEXT_REF_TO.
1184      First remove us from any pointer list we are on.  */
1185   if (TREE_CODE (t) == POINTER_TYPE)
1186     {
1187       if (TYPE_POINTER_TO (TREE_TYPE (t)) == t)
1188         TYPE_POINTER_TO (TREE_TYPE (t)) = TYPE_NEXT_PTR_TO (t);
1189       else
1190         {
1191           tree tem = TYPE_POINTER_TO (TREE_TYPE (t));
1192           while (tem && TYPE_NEXT_PTR_TO (tem) != t)
1193             tem = TYPE_NEXT_PTR_TO (tem);
1194           if (tem)
1195             TYPE_NEXT_PTR_TO (tem) = TYPE_NEXT_PTR_TO (t);
1196         }
1197       TYPE_NEXT_PTR_TO (t) = NULL_TREE;
1198     }
1199   else if (TREE_CODE (t) == REFERENCE_TYPE)
1200     {
1201       if (TYPE_REFERENCE_TO (TREE_TYPE (t)) == t)
1202         TYPE_REFERENCE_TO (TREE_TYPE (t)) = TYPE_NEXT_REF_TO (t);
1203       else
1204         {
1205           tree tem = TYPE_REFERENCE_TO (TREE_TYPE (t));
1206           while (tem && TYPE_NEXT_REF_TO (tem) != t)
1207             tem = TYPE_NEXT_REF_TO (tem);
1208           if (tem)
1209             TYPE_NEXT_REF_TO (tem) = TYPE_NEXT_REF_TO (t);
1210         }
1211       TYPE_NEXT_REF_TO (t) = NULL_TREE;
1212     }
1213
1214   /* Fixup our type.  */
1215   LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TREE_TYPE (t));
1216
1217   /* Second put us on the list of pointers of the new pointed-to type
1218      if we are a main variant.  This is done in lto_fixup_type after
1219      fixing up our main variant.  */
1220
1221   /* This is not very efficient because we cannot do tail-recursion with
1222      a long chain of trees. */
1223   LTO_FIXUP_SUBTREE (TREE_CHAIN (t));
1224 }
1225
1226 /* Fix up fields of a decl_minimal T.  DATA points to fix-up states.  */
1227
1228 static void
1229 lto_fixup_decl_minimal (tree t, void *data)
1230 {
1231   lto_fixup_common (t, data);
1232   LTO_FIXUP_SUBTREE (DECL_NAME (t));
1233   LTO_FIXUP_SUBTREE (DECL_CONTEXT (t));
1234 }
1235
1236 /* Fix up fields of a decl_common T.  DATA points to fix-up states.  */
1237
1238 static void
1239 lto_fixup_decl_common (tree t, void *data)
1240 {
1241   lto_fixup_decl_minimal (t, data);
1242   LTO_FIXUP_SUBTREE (DECL_SIZE (t));
1243   LTO_FIXUP_SUBTREE (DECL_SIZE_UNIT (t));
1244   LTO_FIXUP_SUBTREE (DECL_INITIAL (t));
1245   LTO_FIXUP_SUBTREE (DECL_ATTRIBUTES (t));
1246   LTO_FIXUP_SUBTREE (DECL_ABSTRACT_ORIGIN (t));
1247 }
1248
1249 /* Fix up fields of a decl_with_vis T.  DATA points to fix-up states.  */
1250
1251 static void
1252 lto_fixup_decl_with_vis (tree t, void *data)
1253 {
1254   lto_fixup_decl_common (t, data);
1255
1256   /* Accessor macro has side-effects, use field-name here. */
1257   LTO_FIXUP_SUBTREE (t->decl_with_vis.assembler_name);
1258
1259   gcc_assert (no_fixup_p (DECL_SECTION_NAME (t)));
1260 }
1261
1262 /* Fix up fields of a decl_non_common T.  DATA points to fix-up states.  */
1263
1264 static void
1265 lto_fixup_decl_non_common (tree t, void *data)
1266 {
1267   lto_fixup_decl_with_vis (t, data);
1268   LTO_FIXUP_SUBTREE (DECL_ARGUMENT_FLD (t));
1269   LTO_FIXUP_SUBTREE (DECL_RESULT_FLD (t));
1270   LTO_FIXUP_SUBTREE (DECL_VINDEX (t));
1271
1272   /* SAVED_TREE should not cleared by now.  Also no accessor for base type. */
1273   gcc_assert (no_fixup_p (t->decl_non_common.saved_tree));
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_function (tree t, void *data)
1280 {
1281   lto_fixup_decl_non_common (t, data);
1282   LTO_FIXUP_SUBTREE (DECL_FUNCTION_PERSONALITY (t));
1283 }
1284
1285 /* Fix up fields of a field_decl T.  DATA points to fix-up states.  */
1286
1287 static void
1288 lto_fixup_field_decl (tree t, void *data)
1289 {
1290   lto_fixup_decl_common (t, data);
1291   LTO_FIXUP_SUBTREE (DECL_FIELD_OFFSET (t));
1292   LTO_FIXUP_SUBTREE (DECL_BIT_FIELD_TYPE (t));
1293   LTO_FIXUP_SUBTREE (DECL_QUALIFIER (t));
1294   gcc_assert (no_fixup_p (DECL_FIELD_BIT_OFFSET (t)));
1295   LTO_FIXUP_SUBTREE (DECL_FCONTEXT (t));
1296 }
1297
1298 /* Fix up fields of a type T.  DATA points to fix-up states.  */
1299
1300 static void
1301 lto_fixup_type (tree t, void *data)
1302 {
1303   tree tem, mv;
1304
1305   lto_fixup_common (t, data);
1306   LTO_FIXUP_SUBTREE (TYPE_CACHED_VALUES (t));
1307   LTO_FIXUP_SUBTREE (TYPE_SIZE (t));
1308   LTO_FIXUP_SUBTREE (TYPE_SIZE_UNIT (t));
1309   LTO_FIXUP_SUBTREE (TYPE_ATTRIBUTES (t));
1310   LTO_FIXUP_SUBTREE (TYPE_NAME (t));
1311
1312   /* Accessors are for derived node types only. */
1313   if (!POINTER_TYPE_P (t))
1314     LTO_FIXUP_SUBTREE (t->type.minval);
1315   LTO_FIXUP_SUBTREE (t->type.maxval);
1316
1317   /* Accessor is for derived node types only. */
1318   LTO_FIXUP_SUBTREE (t->type.binfo);
1319
1320   if (TYPE_CONTEXT (t))
1321     {
1322       if (TYPE_P (TYPE_CONTEXT (t)))
1323         LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TYPE_CONTEXT (t));
1324       else
1325         LTO_FIXUP_SUBTREE (TYPE_CONTEXT (t));
1326     }
1327   LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TYPE_CANONICAL (t));
1328
1329   /* The following re-creates proper variant lists while fixing up
1330      the variant leaders.  We do not stream TYPE_NEXT_VARIANT so the
1331      variant list state before fixup is broken.  */
1332
1333   /* Remove us from our main variant list if we are not the variant leader.  */
1334   if (TYPE_MAIN_VARIANT (t) != t)
1335     {
1336       tem = TYPE_MAIN_VARIANT (t);
1337       while (tem && TYPE_NEXT_VARIANT (tem) != t)
1338         tem = TYPE_NEXT_VARIANT (tem);
1339       if (tem)
1340         TYPE_NEXT_VARIANT (tem) = TYPE_NEXT_VARIANT (t);
1341       TYPE_NEXT_VARIANT (t) = NULL_TREE;
1342     }
1343
1344   /* Query our new main variant.  */
1345   mv = gimple_register_type (TYPE_MAIN_VARIANT (t));
1346
1347   /* If we were the variant leader and we get replaced ourselves drop
1348      all variants from our list.  */
1349   if (TYPE_MAIN_VARIANT (t) == t
1350       && mv != t)
1351     {
1352       tem = t;
1353       while (tem)
1354         {
1355           tree tem2 = TYPE_NEXT_VARIANT (tem);
1356           TYPE_NEXT_VARIANT (tem) = NULL_TREE;
1357           tem = tem2;
1358         }
1359     }
1360
1361   /* If we are not our own variant leader link us into our new leaders
1362      variant list.  */
1363   if (mv != t)
1364     {
1365       TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (mv);
1366       TYPE_NEXT_VARIANT (mv) = t;
1367     }
1368
1369   /* Finally adjust our main variant and fix it up.  */
1370   TYPE_MAIN_VARIANT (t) = mv;
1371   LTO_FIXUP_SUBTREE (TYPE_MAIN_VARIANT (t));
1372
1373   /* As the second step of reconstructing the pointer chains put us
1374      on the list of pointers of the new pointed-to type
1375      if we are a main variant.  See lto_fixup_common for the first step.  */
1376   if (TREE_CODE (t) == POINTER_TYPE
1377       && TYPE_MAIN_VARIANT (t) == t)
1378     {
1379       TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (TREE_TYPE (t));
1380       TYPE_POINTER_TO (TREE_TYPE (t)) = t;
1381     }
1382   else if (TREE_CODE (t) == REFERENCE_TYPE
1383            && TYPE_MAIN_VARIANT (t) == t)
1384     {
1385       TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (TREE_TYPE (t));
1386       TYPE_REFERENCE_TO (TREE_TYPE (t)) = t;
1387     }
1388 }
1389
1390 /* Fix up fields of a BINFO T.  DATA points to fix-up states.  */
1391
1392 static void
1393 lto_fixup_binfo (tree t, void *data)
1394 {
1395   unsigned HOST_WIDE_INT i, n;
1396   tree base, saved_base;
1397
1398   lto_fixup_common (t, data);
1399   gcc_assert (no_fixup_p (BINFO_OFFSET (t)));
1400   LTO_FIXUP_SUBTREE (BINFO_VTABLE (t));
1401   LTO_FIXUP_SUBTREE (BINFO_VIRTUALS (t));
1402   LTO_FIXUP_SUBTREE (BINFO_VPTR_FIELD (t));
1403   n = VEC_length (tree, BINFO_BASE_ACCESSES (t));
1404   for (i = 0; i < n; i++)
1405     {
1406       saved_base = base = BINFO_BASE_ACCESS (t, i);
1407       LTO_FIXUP_SUBTREE (base);
1408       if (base != saved_base)
1409         VEC_replace (tree, BINFO_BASE_ACCESSES (t), i, base);
1410     }
1411   LTO_FIXUP_SUBTREE (BINFO_INHERITANCE_CHAIN (t));
1412   LTO_FIXUP_SUBTREE (BINFO_SUBVTT_INDEX (t));
1413   LTO_FIXUP_SUBTREE (BINFO_VPTR_INDEX (t));
1414   n = BINFO_N_BASE_BINFOS (t);
1415   for (i = 0; i < n; i++)
1416     {
1417       saved_base = base = BINFO_BASE_BINFO (t, i);
1418       LTO_FIXUP_SUBTREE (base);
1419       if (base != saved_base)
1420         VEC_replace (tree, BINFO_BASE_BINFOS (t), i, base);
1421     }
1422 }
1423
1424 /* Fix up fields of a CONSTRUCTOR T.  DATA points to fix-up states.  */
1425
1426 static void
1427 lto_fixup_constructor (tree t, void *data)
1428 {
1429   unsigned HOST_WIDE_INT idx;
1430   constructor_elt *ce;
1431
1432   LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TREE_TYPE (t));
1433
1434   for (idx = 0;
1435        VEC_iterate(constructor_elt, CONSTRUCTOR_ELTS (t), idx, ce);
1436        idx++)
1437     {
1438       LTO_FIXUP_SUBTREE (ce->index);
1439       LTO_FIXUP_SUBTREE (ce->value);
1440     }
1441 }
1442
1443 /* A walk_tree callback used by lto_fixup_state. TP is the pointer to the
1444    current tree. WALK_SUBTREES indicates if the subtrees will be walked.
1445    DATA is a pointer set to record visited nodes. */
1446
1447 static tree
1448 lto_fixup_tree (tree *tp, int *walk_subtrees, void *data)
1449 {
1450   tree t;
1451   lto_fixup_data_t *fixup_data = (lto_fixup_data_t *) data;
1452   tree prevailing;
1453
1454   t = *tp;
1455   *walk_subtrees = 0;
1456   if (pointer_set_contains (fixup_data->seen, t))
1457     return NULL;
1458
1459   if (TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == FUNCTION_DECL)
1460     {
1461       prevailing = lto_symtab_prevailing_decl (t);
1462
1463       if (t != prevailing)
1464         {
1465            /* Also replace t with prevailing defintion.  We don't want to
1466               insert the other defintion in the seen set as we want to
1467               replace all instances of it.  */
1468           *tp = prevailing;
1469           t = prevailing;
1470         }
1471     }
1472   else if (TYPE_P (t))
1473     {
1474       /* Replace t with the prevailing type.  We don't want to insert the
1475          other type in the seen set as we want to replace all instances of it.  */
1476       t = gimple_register_type (t);
1477       *tp = t;
1478     }
1479
1480   if (pointer_set_insert (fixup_data->seen, t))
1481     return NULL;
1482
1483   /* walk_tree does not visit all reachable nodes that need to be fixed up.
1484      Hence we do special processing here for those kind of nodes. */
1485   switch (TREE_CODE (t))
1486     {
1487     case FIELD_DECL:
1488       lto_fixup_field_decl (t, data);
1489       break;
1490
1491     case LABEL_DECL:
1492     case CONST_DECL:
1493     case PARM_DECL:
1494     case RESULT_DECL:
1495     case IMPORTED_DECL:
1496       lto_fixup_decl_common (t, data);
1497       break;
1498
1499     case VAR_DECL:
1500       lto_fixup_decl_with_vis (t, data);
1501       break;    
1502
1503     case TYPE_DECL:
1504       lto_fixup_decl_non_common (t, data);
1505       break;
1506
1507     case FUNCTION_DECL:
1508       lto_fixup_function (t, data);
1509       break;
1510
1511     case TREE_BINFO:
1512       lto_fixup_binfo (t, data);
1513       break;
1514
1515     default:
1516       if (TYPE_P (t))
1517         lto_fixup_type (t, data);
1518       else if (TREE_CODE (t) == CONSTRUCTOR)
1519         lto_fixup_constructor (t, data);
1520       else if (CONSTANT_CLASS_P (t))
1521         LTO_REGISTER_TYPE_AND_FIXUP_SUBTREE (TREE_TYPE (t));
1522       else if (EXPR_P (t))
1523         {
1524           /* walk_tree only handles TREE_OPERANDs. Do the rest here.  */
1525           lto_fixup_common (t, data);
1526           LTO_FIXUP_SUBTREE (t->exp.block);
1527           *walk_subtrees = 1;
1528         }
1529       else
1530         {
1531           /* Let walk_tree handle sub-trees.  */
1532           *walk_subtrees = 1;
1533         }
1534     }
1535
1536   return NULL;
1537 }
1538
1539 /* Helper function of lto_fixup_decls. Walks the var and fn streams in STATE,
1540    replaces var and function decls with the corresponding prevailing def and
1541    records the old decl in the free-list in DATA. We also record visted nodes
1542    in the seen-set in DATA to avoid multiple visit for nodes that need not
1543    to be replaced.  */
1544
1545 static void
1546 lto_fixup_state (struct lto_in_decl_state *state, lto_fixup_data_t *data)
1547 {
1548   unsigned i, si;
1549   struct lto_tree_ref_table *table;
1550
1551   /* Although we only want to replace FUNCTION_DECLs and VAR_DECLs,
1552      we still need to walk from all DECLs to find the reachable
1553      FUNCTION_DECLs and VAR_DECLs.  */
1554   for (si = 0; si < LTO_N_DECL_STREAMS; si++)
1555     {
1556       table = &state->streams[si];
1557       for (i = 0; i < table->size; i++)
1558         walk_tree (table->trees + i, lto_fixup_tree, data, NULL);
1559     }
1560 }
1561
1562 /* A callback of htab_traverse. Just extract a state from SLOT and the
1563    lto_fixup_data_t object from AUX and calls lto_fixup_state. */
1564
1565 static int
1566 lto_fixup_state_aux (void **slot, void *aux)
1567 {
1568   struct lto_in_decl_state *state = (struct lto_in_decl_state *) *slot;
1569   lto_fixup_state (state, (lto_fixup_data_t *) aux);
1570   return 1;
1571 }
1572
1573 /* Fix the decls from all FILES. Replaces each decl with the corresponding
1574    prevailing one.  */
1575
1576 static void
1577 lto_fixup_decls (struct lto_file_decl_data **files)
1578 {
1579   unsigned int i;
1580   tree decl;
1581   struct pointer_set_t *seen = pointer_set_create ();
1582   lto_fixup_data_t data;
1583
1584   data.seen = seen;
1585   for (i = 0; files[i]; i++)
1586     {
1587       struct lto_file_decl_data *file = files[i];
1588       struct lto_in_decl_state *state = file->global_decl_state;
1589       lto_fixup_state (state, &data);
1590
1591       htab_traverse (file->function_decl_states, lto_fixup_state_aux, &data);
1592     }
1593
1594   for (i = 0; VEC_iterate (tree, lto_global_var_decls, i, decl); i++)
1595     {
1596       tree saved_decl = decl;
1597       walk_tree (&decl, lto_fixup_tree, &data, NULL);
1598       if (decl != saved_decl)
1599         VEC_replace (tree, lto_global_var_decls, i, decl);
1600     }
1601
1602   pointer_set_destroy (seen);
1603 }
1604
1605 /* Unlink a temporary LTRANS file unless requested otherwise.  */
1606
1607 static void
1608 lto_maybe_unlink (const char *file)
1609 {
1610   if (!getenv ("WPA_SAVE_LTRANS"))
1611     {
1612       if (unlink_if_ordinary (file))
1613         error ("deleting LTRANS input file %s: %m", file);
1614     }
1615   else
1616     fprintf (stderr, "[Leaving LTRANS input file %s]\n", file);
1617 }
1618
1619 /* Read the options saved from each file in the command line.  Called
1620    from lang_hooks.post_options which is called by process_options
1621    right before all the options are used to initialize the compiler.
1622    This assumes that decode_options has already run, so the
1623    num_in_fnames and in_fnames are properly set.
1624
1625    Note that this assumes that all the files had been compiled with
1626    the same options, which is not a good assumption.  In general,
1627    options ought to be read from all the files in the set and merged.
1628    However, it is still unclear what the merge rules should be.  */
1629
1630 void
1631 lto_read_all_file_options (void)
1632 {
1633   size_t i;
1634
1635   /* Clear any file options currently saved.  */
1636   lto_clear_file_options ();
1637
1638   /* Set the hooks to read ELF sections.  */
1639   lto_set_in_hooks (NULL, get_section_data, free_section_data);
1640
1641   for (i = 0; i < num_in_fnames; i++)
1642     {
1643       struct lto_file_decl_data *file_data;
1644       lto_file *file = lto_obj_file_open (in_fnames[i], false);
1645       if (!file)
1646         break;
1647
1648       file_data = XCNEW (struct lto_file_decl_data);
1649       file_data->file_name = file->filename;
1650       file_data->section_hash_table = lto_obj_build_section_table (file);
1651
1652       lto_read_file_options (file_data);
1653
1654       lto_obj_file_close (file);
1655       htab_delete (file_data->section_hash_table);
1656       free (file_data);
1657     }
1658
1659   /* Apply globally the options read from all the files.  */
1660   lto_reissue_options ();
1661 }
1662
1663 static GTY((length ("lto_stats.num_input_files + 1"))) struct lto_file_decl_data **all_file_decl_data;
1664
1665 /* Read all the symbols from the input files FNAMES.  NFILES is the
1666    number of files requested in the command line.  Instantiate a
1667    global call graph by aggregating all the sub-graphs found in each
1668    file.  */
1669
1670 static void
1671 read_cgraph_and_symbols (unsigned nfiles, const char **fnames)
1672 {
1673   unsigned int i, last_file_ix;
1674   FILE *resolution;
1675   struct cgraph_node *node;
1676
1677   lto_stats.num_input_files = nfiles;
1678
1679   timevar_push (TV_IPA_LTO_DECL_IO);
1680
1681   /* Set the hooks so that all of the ipa passes can read in their data.  */
1682   all_file_decl_data = GGC_CNEWVEC (struct lto_file_decl_data *, nfiles + 1);
1683   lto_set_in_hooks (all_file_decl_data, get_section_data, free_section_data);
1684
1685   /* Read the resolution file.  */
1686   resolution = NULL;
1687   if (resolution_file_name)
1688     {
1689       int t;
1690       unsigned num_objects;
1691
1692       resolution = fopen (resolution_file_name, "r");
1693       if (resolution == NULL)
1694         fatal_error ("could not open symbol resolution file: %s",
1695                      xstrerror (errno));
1696
1697       t = fscanf (resolution, "%u", &num_objects);
1698       gcc_assert (t == 1);
1699
1700       /* True, since the plugin splits the archives.  */
1701       gcc_assert (num_objects == nfiles);
1702     }
1703
1704   if (!quiet_flag)
1705     fprintf (stderr, "Reading object files:");
1706
1707   /* Read all of the object files specified on the command line.  */
1708   for (i = 0, last_file_ix = 0; i < nfiles; ++i)
1709     {
1710       struct lto_file_decl_data *file_data = NULL;
1711       if (!quiet_flag)
1712         {
1713           fprintf (stderr, " %s", fnames[i]);
1714           fflush (stderr);
1715         }
1716
1717       current_lto_file = lto_obj_file_open (fnames[i], false);
1718       if (!current_lto_file)
1719         break;
1720
1721       file_data = lto_file_read (current_lto_file, resolution);
1722       if (!file_data)
1723         break;
1724
1725       all_file_decl_data[last_file_ix++] = file_data;
1726
1727       lto_obj_file_close (current_lto_file);
1728       current_lto_file = NULL;
1729       ggc_collect ();
1730     }
1731
1732   if (resolution_file_name)
1733     fclose (resolution);
1734
1735   all_file_decl_data[last_file_ix] = NULL;
1736
1737   /* Set the hooks so that all of the ipa passes can read in their data.  */
1738   lto_set_in_hooks (all_file_decl_data, get_section_data, free_section_data);
1739
1740   timevar_pop (TV_IPA_LTO_DECL_IO);
1741
1742   if (!quiet_flag)
1743     fprintf (stderr, "\nReading the callgraph\n");
1744
1745   timevar_push (TV_IPA_LTO_CGRAPH_IO);
1746   /* Read the callgraph.  */
1747   input_cgraph ();
1748   timevar_pop (TV_IPA_LTO_CGRAPH_IO);
1749
1750   if (!quiet_flag)
1751     fprintf (stderr, "Merging declarations\n");
1752
1753   timevar_push (TV_IPA_LTO_DECL_MERGE);
1754   /* Merge global decls.  */
1755   lto_symtab_merge_decls ();
1756
1757   /* Fixup all decls and types and free the type hash tables.  */
1758   lto_fixup_decls (all_file_decl_data);
1759   free_gimple_type_tables ();
1760   ggc_collect ();
1761
1762   timevar_pop (TV_IPA_LTO_DECL_MERGE);
1763   /* Each pass will set the appropriate timer.  */
1764
1765   if (!quiet_flag)
1766     fprintf (stderr, "Reading summaries\n");
1767
1768   /* Read the IPA summary data.  */
1769   if (flag_ltrans)
1770     ipa_read_optimization_summaries ();
1771   else
1772     ipa_read_summaries ();
1773
1774   /* Finally merge the cgraph according to the decl merging decisions.  */
1775   timevar_push (TV_IPA_LTO_CGRAPH_MERGE);
1776   lto_symtab_merge_cgraph_nodes ();
1777   ggc_collect ();
1778
1779   if (flag_ltrans)
1780     for (node = cgraph_nodes; node; node = node->next)
1781       {
1782         /* FIXME: ipa_transforms_to_apply holds list of passes that have optimization
1783            summaries computed and needs to apply changes.  At the moment WHOPR only
1784            supports inlining, so we can push it here by hand.  In future we need to stream
1785            this field into ltrans compilation.  */
1786         if (node->analyzed)
1787           VEC_safe_push (ipa_opt_pass, heap,
1788                          node->ipa_transforms_to_apply,
1789                          (ipa_opt_pass)&pass_ipa_inline);
1790       }
1791   timevar_pop (TV_IPA_LTO_CGRAPH_MERGE);
1792
1793   timevar_push (TV_IPA_LTO_DECL_INIT_IO);
1794
1795   /* FIXME lto. This loop needs to be changed to use the pass manager to
1796      call the ipa passes directly.  */
1797   if (!errorcount)
1798     for (i = 0; i < last_file_ix; i++)
1799       {
1800         struct lto_file_decl_data *file_data = all_file_decl_data [i];
1801         lto_materialize_constructors_and_inits (file_data);
1802       }
1803
1804   /* Indicate that the cgraph is built and ready.  */
1805   cgraph_function_flags_ready = true;
1806
1807   timevar_pop (TV_IPA_LTO_DECL_INIT_IO);
1808   ggc_free (all_file_decl_data);
1809   all_file_decl_data = NULL;
1810 }
1811
1812
1813 /* Materialize all the bodies for all the nodes in the callgraph.  */
1814
1815 static void
1816 materialize_cgraph (void)
1817 {
1818   tree decl;
1819   struct cgraph_node *node; 
1820   unsigned i;
1821   timevar_id_t lto_timer;
1822
1823   if (!quiet_flag)
1824     fprintf (stderr,
1825              flag_wpa ? "Materializing decls:" : "Reading function bodies:");
1826
1827
1828   /* Now that we have input the cgraph, we need to clear all of the aux
1829      nodes and read the functions if we are not running in WPA mode.  */
1830   timevar_push (TV_IPA_LTO_GIMPLE_IO);
1831
1832   for (node = cgraph_nodes; node; node = node->next)
1833     {
1834       /* Some cgraph nodes get created on the fly, and they don't need
1835          to be materialized.  For instance, nodes for nested functions
1836          where the parent function was not streamed out or builtin
1837          functions.  Additionally, builtin functions should not be
1838          materialized and may, in fact, cause confusion because there
1839          may be a regular function in the file whose assembler name
1840          matches that of the function.
1841          See gcc.c-torture/execute/20030125-1.c and
1842          gcc.c-torture/execute/921215-1.c.  */
1843       if (node->local.lto_file_data
1844           && !DECL_IS_BUILTIN (node->decl))
1845         {
1846           announce_function (node->decl);
1847           lto_materialize_function (node);
1848           lto_stats.num_input_cgraph_nodes++;
1849         }
1850     }
1851
1852   timevar_pop (TV_IPA_LTO_GIMPLE_IO);
1853
1854   /* Start the appropriate timer depending on the mode that we are
1855      operating in.  */
1856   lto_timer = (flag_wpa) ? TV_WHOPR_WPA
1857               : (flag_ltrans) ? TV_WHOPR_LTRANS
1858               : TV_LTO;
1859   timevar_push (lto_timer);
1860
1861   current_function_decl = NULL;
1862   set_cfun (NULL);
1863
1864   /* Inform the middle end about the global variables we have seen.  */
1865   for (i = 0; VEC_iterate (tree, lto_global_var_decls, i, decl); i++)
1866     rest_of_decl_compilation (decl, 1, 0);
1867
1868   if (!quiet_flag)
1869     fprintf (stderr, "\n");
1870
1871   timevar_pop (lto_timer);
1872 }
1873
1874
1875 /* Perform whole program analysis (WPA) on the callgraph and write out the
1876    optimization plan.  */
1877
1878 static void
1879 do_whole_program_analysis (void)
1880 {
1881   char **output_files;
1882   size_t i;
1883
1884   /* Note that since we are in WPA mode, materialize_cgraph will not
1885      actually read in all the function bodies.  It only materializes
1886      the decls and cgraph nodes so that analysis can be performed.  */
1887   materialize_cgraph ();
1888
1889   /* Reading in the cgraph uses different timers, start timing WPA now.  */
1890   timevar_push (TV_WHOPR_WPA);
1891
1892   if (pre_ipa_mem_report)
1893     {
1894       fprintf (stderr, "Memory consumption before IPA\n");
1895       dump_memory_report (false);
1896     }
1897
1898   cgraph_function_flags_ready = true;
1899   bitmap_obstack_initialize (NULL);
1900   ipa_register_cgraph_hooks ();
1901   cgraph_state = CGRAPH_STATE_IPA_SSA;
1902
1903   execute_ipa_pass_list (all_regular_ipa_passes);
1904
1905   verify_cgraph ();
1906   bitmap_obstack_release (NULL);
1907
1908   /* We are about to launch the final LTRANS phase, stop the WPA timer.  */
1909   timevar_pop (TV_WHOPR_WPA);
1910
1911   lto_1_to_1_map ();
1912
1913   if (!quiet_flag)
1914     {
1915       fprintf (stderr, "\nStreaming out");
1916       fflush (stderr);
1917     }
1918   output_files = lto_wpa_write_files ();
1919   ggc_collect ();
1920   if (!quiet_flag)
1921     fprintf (stderr, "\n");
1922
1923   if (post_ipa_mem_report)
1924     {
1925       fprintf (stderr, "Memory consumption after IPA\n");
1926       dump_memory_report (false);
1927     }
1928
1929   /* Show the LTO report before launching LTRANS.  */
1930   if (flag_lto_report)
1931     print_lto_report ();
1932
1933   lto_execute_ltrans (output_files);
1934
1935   for (i = 0; output_files[i]; ++i)
1936     {
1937       if (output_files[i][0] != '*')
1938         lto_maybe_unlink (output_files[i]);
1939
1940       free (output_files[i]);
1941     }
1942
1943   XDELETEVEC (output_files);
1944 }
1945
1946
1947 /* Main entry point for the GIMPLE front end.  This front end has
1948    three main personalities:
1949
1950    - LTO (-flto).  All the object files on the command line are
1951      loaded in memory and processed as a single translation unit.
1952      This is the traditional link-time optimization behavior.
1953
1954    - WPA (-fwpa).  Only the callgraph and summary information for
1955      files in the command file are loaded.  A single callgraph
1956      (without function bodies) is instantiated for the whole set of
1957      files.  IPA passes are only allowed to analyze the call graph
1958      and make transformation decisions.  The callgraph is
1959      partitioned, each partition is written to a new object file
1960      together with the transformation decisions.
1961
1962    - LTRANS (-fltrans).  Similar to -flto but it prevents the IPA
1963      summary files from running again.  Since WPA computed summary
1964      information and decided what transformations to apply, LTRANS
1965      simply applies them.  */
1966
1967 void
1968 lto_main (int debug_p ATTRIBUTE_UNUSED)
1969 {
1970   lto_init_reader ();
1971
1972   /* Read all the symbols and call graph from all the files in the
1973      command line.  */
1974   read_cgraph_and_symbols (num_in_fnames, in_fnames);
1975
1976   if (!errorcount)
1977     {
1978       /* If WPA is enabled analyze the whole call graph and create an
1979          optimization plan.  Otherwise, read in all the function
1980          bodies and continue with optimization.  */
1981       if (flag_wpa)
1982         do_whole_program_analysis ();
1983       else
1984         {
1985           materialize_cgraph ();
1986
1987           /* Let the middle end know that we have read and merged all of
1988              the input files.  */ 
1989           cgraph_optimize ();
1990
1991           /* FIXME lto, if the processes spawned by WPA fail, we miss
1992              the chance to print WPA's report, so WPA will call
1993              print_lto_report before launching LTRANS.  If LTRANS was
1994              launched directly by the driver we would not need to do
1995              this.  */
1996           if (flag_lto_report)
1997             print_lto_report ();
1998         }
1999     }
2000 }
2001
2002 #include "gt-lto-lto.h"