OSDN Git Service

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