OSDN Git Service

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