OSDN Git Service

Use 64bit integer for LTO symbol ID.
[pf3gnuchains/gcc-fork.git] / gcc / lto / lto.c
1 /* Top-level LTO routines.
2    Copyright 2009, 2010, 2011 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 "tree-flow.h"
28 #include "diagnostic-core.h"
29 #include "tm.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 "tree-streamer.h"
47 #include "splay-tree.h"
48 #include "params.h"
49 #include "ipa-inline.h"
50 #include "ipa-utils.h"
51
52 static GTY(()) tree first_personality_decl;
53
54 /* Returns a hash code for P.  */
55
56 static hashval_t
57 hash_name (const void *p)
58 {
59   const struct lto_section_slot *ds = (const struct lto_section_slot *) p;
60   return (hashval_t) htab_hash_string (ds->name);
61 }
62
63
64 /* Returns nonzero if P1 and P2 are equal.  */
65
66 static int
67 eq_name (const void *p1, const void *p2)
68 {
69   const struct lto_section_slot *s1 =
70     (const struct lto_section_slot *) p1;
71   const struct lto_section_slot *s2 =
72     (const struct lto_section_slot *) p2;
73
74   return strcmp (s1->name, s2->name) == 0;
75 }
76
77 /* Free lto_section_slot */
78
79 static void
80 free_with_string (void *arg)
81 {
82   struct lto_section_slot *s = (struct lto_section_slot *)arg;
83
84   free (CONST_CAST (char *, s->name));
85   free (arg);
86 }
87
88 /* Create section hash table */
89
90 htab_t 
91 lto_obj_create_section_hash_table (void)
92 {
93   return htab_create (37, hash_name, eq_name, free_with_string);
94 }
95
96 /* Delete an allocated integer KEY in the splay tree.  */
97
98 static void
99 lto_splay_tree_delete_id (splay_tree_key key)
100 {
101   free ((void *) key);
102 }
103
104 /* Compare splay tree node ids A and B.  */
105
106 static int
107 lto_splay_tree_compare_ids (splay_tree_key a, splay_tree_key b)
108 {
109   unsigned HOST_WIDE_INT ai;
110   unsigned HOST_WIDE_INT bi;
111
112   ai = *(unsigned HOST_WIDE_INT *) a;
113   bi = *(unsigned HOST_WIDE_INT *) b;
114
115   if (ai < bi)
116     return -1;
117   else if (ai > bi)
118     return 1;
119   return 0;
120 }
121
122 /* Look up splay tree node by ID in splay tree T.  */
123
124 static splay_tree_node
125 lto_splay_tree_lookup (splay_tree t, unsigned HOST_WIDE_INT id)
126 {
127   return splay_tree_lookup (t, (splay_tree_key) &id);
128 }
129
130 /* Check if KEY has ID.  */
131
132 static bool
133 lto_splay_tree_id_equal_p (splay_tree_key key, unsigned HOST_WIDE_INT id)
134 {
135   return *(unsigned HOST_WIDE_INT *) key == id;
136 }
137
138 /* Insert a splay tree node into tree T with ID as key and FILE_DATA as value. 
139    The ID is allocated separately because we need HOST_WIDE_INTs which may
140    be wider than a splay_tree_key. */
141
142 static void
143 lto_splay_tree_insert (splay_tree t, unsigned HOST_WIDE_INT id,
144                        struct lto_file_decl_data *file_data)
145 {
146   unsigned HOST_WIDE_INT *idp = XCNEW (unsigned HOST_WIDE_INT);
147   *idp = id;
148   splay_tree_insert (t, (splay_tree_key) idp, (splay_tree_value) file_data);
149 }
150
151 /* Create a splay tree.  */
152
153 static splay_tree
154 lto_splay_tree_new (void)
155 {
156   return splay_tree_new (lto_splay_tree_compare_ids,
157                          lto_splay_tree_delete_id,
158                          NULL);
159 }
160
161 /* Read the constructors and inits.  */
162
163 static void
164 lto_materialize_constructors_and_inits (struct lto_file_decl_data * file_data)
165 {
166   size_t len;
167   const char *data = lto_get_section_data (file_data, 
168                                            LTO_section_static_initializer,
169                                            NULL, &len);
170   lto_input_constructors_and_inits (file_data, data);
171   lto_free_section_data (file_data, LTO_section_static_initializer, NULL,
172                          data, len);
173 }
174
175 /* Return true when NODE has a clone that is analyzed (i.e. we need
176    to load its body even if the node itself is not needed).  */
177
178 static bool
179 has_analyzed_clone_p (struct cgraph_node *node)
180 {
181   struct cgraph_node *orig = node;
182   node = node->clones;
183   if (node)
184     while (node != orig)
185       {
186         if (node->analyzed)
187           return true;
188         if (node->clones)
189           node = node->clones;
190         else if (node->next_sibling_clone)
191           node = node->next_sibling_clone;
192         else
193           {
194             while (node != orig && !node->next_sibling_clone)
195               node = node->clone_of;
196             if (node != orig)
197               node = node->next_sibling_clone;
198           }
199       }
200   return false;
201 }
202
203 /* Read the function body for the function associated with NODE.  */
204
205 static void
206 lto_materialize_function (struct cgraph_node *node)
207 {
208   tree decl;
209   struct lto_file_decl_data *file_data;
210   const char *data, *name;
211   size_t len;
212
213   decl = node->decl;
214   /* Read in functions with body (analyzed nodes)
215      and also functions that are needed to produce virtual clones.  */
216   if (cgraph_function_with_gimple_body_p (node) || has_analyzed_clone_p (node))
217     {
218       /* Clones and thunks don't need to be read.  */
219       if (node->clone_of)
220         return;
221
222       /* Load the function body only if not operating in WPA mode.  In
223          WPA mode, the body of the function is not needed.  */
224       if (!flag_wpa)
225         {
226           file_data = node->local.lto_file_data;
227           name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
228
229           /* We may have renamed the declaration, e.g., a static function.  */
230           name = lto_get_decl_name_mapping (file_data, name);
231
232           data = lto_get_section_data (file_data, LTO_section_function_body,
233                                        name, &len);
234           if (!data)
235             fatal_error ("%s: section %s is missing",
236                          file_data->file_name,
237                          name);
238
239           gcc_assert (DECL_STRUCT_FUNCTION (decl) == NULL);
240
241           allocate_struct_function (decl, false);
242           announce_function (decl);
243           lto_input_function_body (file_data, decl, data);
244           if (DECL_FUNCTION_PERSONALITY (decl) && !first_personality_decl)
245             first_personality_decl = DECL_FUNCTION_PERSONALITY (decl);
246           lto_stats.num_function_bodies++;
247           lto_free_section_data (file_data, LTO_section_function_body, name,
248                                  data, len);
249           ggc_collect ();
250         }
251     }
252
253   /* Let the middle end know about the function.  */
254   rest_of_decl_compilation (decl, 1, 0);
255 }
256
257
258 /* Decode the content of memory pointed to by DATA in the in decl
259    state object STATE. DATA_IN points to a data_in structure for
260    decoding. Return the address after the decoded object in the
261    input.  */
262
263 static const uint32_t *
264 lto_read_in_decl_state (struct data_in *data_in, const uint32_t *data,
265                         struct lto_in_decl_state *state)
266 {
267   uint32_t ix;
268   tree decl;
269   uint32_t i, j;
270   
271   ix = *data++;
272   decl = streamer_tree_cache_get (data_in->reader_cache, ix);
273   if (TREE_CODE (decl) != FUNCTION_DECL)
274     {
275       gcc_assert (decl == void_type_node);
276       decl = NULL_TREE;
277     }
278   state->fn_decl = decl;
279
280   for (i = 0; i < LTO_N_DECL_STREAMS; i++)
281     {
282       uint32_t size = *data++;
283       tree *decls = ggc_alloc_vec_tree (size);
284
285       for (j = 0; j < size; j++)
286         decls[j] = streamer_tree_cache_get (data_in->reader_cache, data[j]);
287
288       state->streams[i].size = size;
289       state->streams[i].trees = decls;
290       data += size;
291     }
292
293   return data;
294 }
295
296 /* A hashtable of trees that potentially refer to variables or functions
297    that must be replaced with their prevailing variant.  */
298 static GTY((if_marked ("ggc_marked_p"), param_is (union tree_node))) htab_t
299   tree_with_vars;
300
301 /* Remember that T is a tree that (potentially) refers to a variable
302    or function decl that may be replaced with its prevailing variant.  */
303 static void
304 remember_with_vars (tree t)
305 {
306   *(tree *) htab_find_slot (tree_with_vars, t, INSERT) = t;
307 }
308
309 #define LTO_FIXUP_TREE(tt) \
310   do \
311     { \
312       if (tt) \
313         { \
314           if (TYPE_P (tt)) \
315             (tt) = gimple_register_type (tt); \
316           if (VAR_OR_FUNCTION_DECL_P (tt) && TREE_PUBLIC (tt)) \
317             remember_with_vars (t); \
318         } \
319     } while (0)
320
321 static void lto_fixup_types (tree);
322
323 /* Fix up fields of a tree_typed T.  */
324
325 static void
326 lto_ft_typed (tree t)
327 {
328   LTO_FIXUP_TREE (TREE_TYPE (t));
329 }
330
331 /* Fix up fields of a tree_common T.  */
332
333 static void
334 lto_ft_common (tree t)
335 {
336   lto_ft_typed (t);
337   LTO_FIXUP_TREE (TREE_CHAIN (t));
338 }
339
340 /* Fix up fields of a decl_minimal T.  */
341
342 static void
343 lto_ft_decl_minimal (tree t)
344 {
345   lto_ft_common (t);
346   LTO_FIXUP_TREE (DECL_NAME (t));
347   LTO_FIXUP_TREE (DECL_CONTEXT (t));
348 }
349
350 /* Fix up fields of a decl_common T.  */
351
352 static void
353 lto_ft_decl_common (tree t)
354 {
355   lto_ft_decl_minimal (t);
356   LTO_FIXUP_TREE (DECL_SIZE (t));
357   LTO_FIXUP_TREE (DECL_SIZE_UNIT (t));
358   LTO_FIXUP_TREE (DECL_INITIAL (t));
359   LTO_FIXUP_TREE (DECL_ATTRIBUTES (t));
360   LTO_FIXUP_TREE (DECL_ABSTRACT_ORIGIN (t));
361 }
362
363 /* Fix up fields of a decl_with_vis T.  */
364
365 static void
366 lto_ft_decl_with_vis (tree t)
367 {
368   lto_ft_decl_common (t);
369
370   /* Accessor macro has side-effects, use field-name here. */
371   LTO_FIXUP_TREE (t->decl_with_vis.assembler_name);
372   LTO_FIXUP_TREE (DECL_SECTION_NAME (t));
373 }
374
375 /* Fix up fields of a decl_non_common T.  */
376
377 static void
378 lto_ft_decl_non_common (tree t)
379 {
380   lto_ft_decl_with_vis (t);
381   LTO_FIXUP_TREE (DECL_ARGUMENT_FLD (t));
382   LTO_FIXUP_TREE (DECL_RESULT_FLD (t));
383   LTO_FIXUP_TREE (DECL_VINDEX (t));
384 }
385
386 /* Fix up fields of a decl_non_common T.  */
387
388 static void
389 lto_ft_function (tree t)
390 {
391   lto_ft_decl_non_common (t);
392   LTO_FIXUP_TREE (DECL_FUNCTION_PERSONALITY (t));
393 }
394
395 /* Fix up fields of a field_decl T.  */
396
397 static void
398 lto_ft_field_decl (tree t)
399 {
400   lto_ft_decl_common (t);
401   LTO_FIXUP_TREE (DECL_FIELD_OFFSET (t));
402   LTO_FIXUP_TREE (DECL_BIT_FIELD_TYPE (t));
403   LTO_FIXUP_TREE (DECL_QUALIFIER (t));
404   LTO_FIXUP_TREE (DECL_FIELD_BIT_OFFSET (t));
405   LTO_FIXUP_TREE (DECL_FCONTEXT (t));
406 }
407
408 /* Fix up fields of a type T.  */
409
410 static void
411 lto_ft_type (tree t)
412 {
413   lto_ft_common (t);
414   LTO_FIXUP_TREE (TYPE_CACHED_VALUES (t));
415   LTO_FIXUP_TREE (TYPE_SIZE (t));
416   LTO_FIXUP_TREE (TYPE_SIZE_UNIT (t));
417   LTO_FIXUP_TREE (TYPE_ATTRIBUTES (t));
418   LTO_FIXUP_TREE (TYPE_NAME (t));
419
420   /* Accessors are for derived node types only. */
421   if (!POINTER_TYPE_P (t))
422     LTO_FIXUP_TREE (TYPE_MINVAL (t));
423   LTO_FIXUP_TREE (TYPE_MAXVAL (t));
424
425   /* Accessor is for derived node types only. */
426   LTO_FIXUP_TREE (t->type_non_common.binfo);
427
428   LTO_FIXUP_TREE (TYPE_CONTEXT (t));
429 }
430
431 /* Fix up fields of a BINFO T.  */
432
433 static void
434 lto_ft_binfo (tree t)
435 {
436   unsigned HOST_WIDE_INT i, n;
437   tree base, saved_base;
438
439   lto_ft_common (t);
440   LTO_FIXUP_TREE (BINFO_VTABLE (t));
441   LTO_FIXUP_TREE (BINFO_OFFSET (t));
442   LTO_FIXUP_TREE (BINFO_VIRTUALS (t));
443   LTO_FIXUP_TREE (BINFO_VPTR_FIELD (t));
444   n = VEC_length (tree, BINFO_BASE_ACCESSES (t));
445   for (i = 0; i < n; i++)
446     {
447       saved_base = base = BINFO_BASE_ACCESS (t, i);
448       LTO_FIXUP_TREE (base);
449       if (base != saved_base)
450         VEC_replace (tree, BINFO_BASE_ACCESSES (t), i, base);
451     }
452   LTO_FIXUP_TREE (BINFO_INHERITANCE_CHAIN (t));
453   LTO_FIXUP_TREE (BINFO_SUBVTT_INDEX (t));
454   LTO_FIXUP_TREE (BINFO_VPTR_INDEX (t));
455   n = BINFO_N_BASE_BINFOS (t);
456   for (i = 0; i < n; i++)
457     {
458       saved_base = base = BINFO_BASE_BINFO (t, i);
459       LTO_FIXUP_TREE (base);
460       if (base != saved_base)
461         VEC_replace (tree, BINFO_BASE_BINFOS (t), i, base);
462     }
463 }
464
465 /* Fix up fields of a CONSTRUCTOR T.  */
466
467 static void
468 lto_ft_constructor (tree t)
469 {
470   unsigned HOST_WIDE_INT idx;
471   constructor_elt *ce;
472
473   lto_ft_typed (t);
474
475   for (idx = 0;
476        VEC_iterate(constructor_elt, CONSTRUCTOR_ELTS (t), idx, ce);
477        idx++)
478     {
479       LTO_FIXUP_TREE (ce->index);
480       LTO_FIXUP_TREE (ce->value);
481     }
482 }
483
484 /* Fix up fields of an expression tree T.  */
485
486 static void
487 lto_ft_expr (tree t)
488 {
489   int i;
490   lto_ft_typed (t);
491   for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i)
492     LTO_FIXUP_TREE (TREE_OPERAND (t, i));
493 }
494
495 /* Given a tree T fixup fields of T by replacing types with their merged
496    variant and other entities by an equal entity from an earlier compilation
497    unit, or an entity being canonical in a different way.  This includes
498    for instance integer or string constants.  */
499
500 static void
501 lto_fixup_types (tree t)
502 {
503   switch (TREE_CODE (t))
504     {
505     case IDENTIFIER_NODE:
506       break;
507
508     case TREE_LIST:
509       LTO_FIXUP_TREE (TREE_VALUE (t));
510       LTO_FIXUP_TREE (TREE_PURPOSE (t));
511       LTO_FIXUP_TREE (TREE_CHAIN (t));
512       break;
513
514     case FIELD_DECL:
515       lto_ft_field_decl (t);
516       break;
517
518     case LABEL_DECL:
519     case CONST_DECL:
520     case PARM_DECL:
521     case RESULT_DECL:
522     case IMPORTED_DECL:
523       lto_ft_decl_common (t);
524       break;
525
526     case VAR_DECL:
527       lto_ft_decl_with_vis (t);
528       break;
529
530     case TYPE_DECL:
531       lto_ft_decl_non_common (t);
532       break;
533
534     case FUNCTION_DECL:
535       lto_ft_function (t);
536       break;
537
538     case TREE_BINFO:
539       lto_ft_binfo (t);
540       break;
541
542     case PLACEHOLDER_EXPR:
543       lto_ft_common (t);
544       break;
545
546     case BLOCK:
547     case TRANSLATION_UNIT_DECL:
548     case OPTIMIZATION_NODE:
549     case TARGET_OPTION_NODE:
550       break;
551
552     default:
553       if (TYPE_P (t))
554         lto_ft_type (t);
555       else if (TREE_CODE (t) == CONSTRUCTOR)
556         lto_ft_constructor (t);
557       else if (CONSTANT_CLASS_P (t))
558         LTO_FIXUP_TREE (TREE_TYPE (t));
559       else if (EXPR_P (t))
560         {
561           lto_ft_expr (t);
562         }
563       else
564         {
565           remember_with_vars (t);
566         }
567     }
568 }
569
570
571 /* Return the resolution for the decl with index INDEX from DATA_IN. */
572
573 static enum ld_plugin_symbol_resolution
574 get_resolution (struct data_in *data_in, unsigned index)
575 {
576   if (data_in->globals_resolution)
577     {
578       ld_plugin_symbol_resolution_t ret;
579       /* We can have references to not emitted functions in
580          DECL_FUNCTION_PERSONALITY at least.  So we can and have
581          to indeed return LDPR_UNKNOWN in some cases.   */
582       if (VEC_length (ld_plugin_symbol_resolution_t,
583                       data_in->globals_resolution) <= index)
584         return LDPR_UNKNOWN;
585       ret = VEC_index (ld_plugin_symbol_resolution_t,
586                        data_in->globals_resolution,
587                        index);
588       return ret;
589     }
590   else
591     /* Delay resolution finding until decl merging.  */
592     return LDPR_UNKNOWN;
593 }
594
595
596 /* Register DECL with the global symbol table and change its
597    name if necessary to avoid name clashes for static globals across
598    different files.  */
599
600 static void
601 lto_register_var_decl_in_symtab (struct data_in *data_in, tree decl)
602 {
603   tree context;
604
605   /* Variable has file scope, not local. Need to ensure static variables
606      between different files don't clash unexpectedly.  */
607   if (!TREE_PUBLIC (decl)
608       && !((context = decl_function_context (decl))
609            && auto_var_in_fn_p (decl, context)))
610     {
611       /* ??? We normally pre-mangle names before we serialize them
612          out.  Here, in lto1, we do not know the language, and
613          thus cannot do the mangling again. Instead, we just
614          append a suffix to the mangled name.  The resulting name,
615          however, is not a properly-formed mangled name, and will
616          confuse any attempt to unmangle it.  */
617       const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
618       char *label;
619
620       ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
621       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
622       rest_of_decl_compilation (decl, 1, 0);
623       VEC_safe_push (tree, gc, lto_global_var_decls, decl);
624     }
625
626   /* If this variable has already been declared, queue the
627      declaration for merging.  */
628   if (TREE_PUBLIC (decl))
629     {
630       unsigned ix;
631       if (!streamer_tree_cache_lookup (data_in->reader_cache, decl, &ix))
632         gcc_unreachable ();
633       lto_symtab_register_decl (decl, get_resolution (data_in, ix),
634                                 data_in->file_data);
635     }
636 }
637
638
639 /* Register DECL with the global symbol table and change its
640    name if necessary to avoid name clashes for static globals across
641    different files.  DATA_IN contains descriptors and tables for the
642    file being read.  */
643
644 static void
645 lto_register_function_decl_in_symtab (struct data_in *data_in, tree decl)
646 {
647   /* Need to ensure static entities between different files
648      don't clash unexpectedly.  */
649   if (!TREE_PUBLIC (decl))
650     {
651       /* We must not use the DECL_ASSEMBLER_NAME macro here, as it
652          may set the assembler name where it was previously empty.  */
653       tree old_assembler_name = decl->decl_with_vis.assembler_name;
654
655       /* FIXME lto: We normally pre-mangle names before we serialize
656          them out.  Here, in lto1, we do not know the language, and
657          thus cannot do the mangling again. Instead, we just append a
658          suffix to the mangled name.  The resulting name, however, is
659          not a properly-formed mangled name, and will confuse any
660          attempt to unmangle it.  */
661       const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
662       char *label;
663
664       ASM_FORMAT_PRIVATE_NAME (label, name, DECL_UID (decl));
665       SET_DECL_ASSEMBLER_NAME (decl, get_identifier (label));
666
667       /* We may arrive here with the old assembler name not set
668          if the function body is not needed, e.g., it has been
669          inlined away and does not appear in the cgraph.  */
670       if (old_assembler_name)
671         {
672           tree new_assembler_name = DECL_ASSEMBLER_NAME (decl);
673
674           /* Make the original assembler name available for later use.
675              We may have used it to indicate the section within its
676              object file where the function body may be found.
677              FIXME lto: Find a better way to maintain the function decl
678              to body section mapping so we don't need this hack.  */
679           lto_record_renamed_decl (data_in->file_data,
680                                    IDENTIFIER_POINTER (old_assembler_name),
681                                    IDENTIFIER_POINTER (new_assembler_name));
682
683           /* Also register the reverse mapping so that we can find the
684              new name given to an existing assembler name (used when
685              restoring alias pairs in input_constructors_or_inits.  */
686           lto_record_renamed_decl (data_in->file_data,
687                                    IDENTIFIER_POINTER (new_assembler_name),
688                                    IDENTIFIER_POINTER (old_assembler_name));
689         }
690     }
691
692   /* If this variable has already been declared, queue the
693      declaration for merging.  */
694   if (TREE_PUBLIC (decl) && !DECL_ABSTRACT (decl))
695     {
696       unsigned ix;
697       if (!streamer_tree_cache_lookup (data_in->reader_cache, decl, &ix))
698         gcc_unreachable ();
699       lto_symtab_register_decl (decl, get_resolution (data_in, ix),
700                                 data_in->file_data);
701     }
702 }
703
704
705 /* Given a streamer cache structure DATA_IN (holding a sequence of trees
706    for one compilation unit) go over all trees starting at index FROM until the
707    end of the sequence and replace fields of those trees, and the trees
708    themself with their canonical variants as per gimple_register_type.  */
709
710 static void
711 uniquify_nodes (struct data_in *data_in, unsigned from)
712 {
713   struct streamer_tree_cache_d *cache = data_in->reader_cache;
714   unsigned len = VEC_length (tree, cache->nodes);
715   unsigned i;
716
717   /* Go backwards because children streamed for the first time come
718      as part of their parents, and hence are created after them.  */
719
720   /* First register all the types in the cache.  This makes sure to
721      have the original structure in the type cycles when registering
722      them and computing hashes.  */
723   for (i = len; i-- > from;)
724     {
725       tree t = VEC_index (tree, cache->nodes, i);
726       if (t && TYPE_P (t))
727         gimple_register_type (t);
728     }
729
730   /* Second fixup all trees in the new cache entries.  */
731   for (i = len; i-- > from;)
732     {
733       tree t = VEC_index (tree, cache->nodes, i);
734       tree oldt = t;
735       if (!t)
736         continue;
737
738       /* First fixup the fields of T.  */
739       lto_fixup_types (t);
740
741       if (!TYPE_P (t))
742         continue;
743
744       /* Now try to find a canonical variant of T itself.  */
745       t = gimple_register_type (t);
746
747       if (t == oldt)
748         {
749           /* The following re-creates proper variant lists while fixing up
750              the variant leaders.  We do not stream TYPE_NEXT_VARIANT so the
751              variant list state before fixup is broken.  */
752           tree tem, mv;
753
754           /* Remove us from our main variant list if we are not the
755              variant leader.  */
756           if (TYPE_MAIN_VARIANT (t) != t)
757             {
758               tem = TYPE_MAIN_VARIANT (t);
759               while (tem && TYPE_NEXT_VARIANT (tem) != t)
760                 tem = TYPE_NEXT_VARIANT (tem);
761               if (tem)
762                 TYPE_NEXT_VARIANT (tem) = TYPE_NEXT_VARIANT (t);
763               TYPE_NEXT_VARIANT (t) = NULL_TREE;
764             }
765
766           /* Query our new main variant.  */
767           mv = gimple_register_type (TYPE_MAIN_VARIANT (t));
768
769           /* If we were the variant leader and we get replaced ourselves drop
770              all variants from our list.  */
771           if (TYPE_MAIN_VARIANT (t) == t
772               && mv != t)
773             {
774               tem = t;
775               while (tem)
776                 {
777                   tree tem2 = TYPE_NEXT_VARIANT (tem);
778                   TYPE_NEXT_VARIANT (tem) = NULL_TREE;
779                   tem = tem2;
780                 }
781             }
782
783           /* If we are not our own variant leader link us into our new leaders
784              variant list.  */
785           if (mv != t)
786             {
787               TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (mv);
788               TYPE_NEXT_VARIANT (mv) = t;
789               if (RECORD_OR_UNION_TYPE_P (t))
790                 TYPE_BINFO (t) = TYPE_BINFO (mv);
791             }
792
793           /* Finally adjust our main variant and fix it up.  */
794           TYPE_MAIN_VARIANT (t) = mv;
795
796           /* The following reconstructs the pointer chains
797              of the new pointed-to type if we are a main variant.  We do
798              not stream those so they are broken before fixup.  */
799           if (TREE_CODE (t) == POINTER_TYPE
800               && TYPE_MAIN_VARIANT (t) == t)
801             {
802               TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (TREE_TYPE (t));
803               TYPE_POINTER_TO (TREE_TYPE (t)) = t;
804             }
805           else if (TREE_CODE (t) == REFERENCE_TYPE
806                    && TYPE_MAIN_VARIANT (t) == t)
807             {
808               TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (TREE_TYPE (t));
809               TYPE_REFERENCE_TO (TREE_TYPE (t)) = t;
810             }
811         }
812
813       else
814         {
815           if (RECORD_OR_UNION_TYPE_P (t))
816             {
817               tree f1, f2;
818               if (TYPE_FIELDS (t) != TYPE_FIELDS (oldt))
819                 for (f1 = TYPE_FIELDS (t), f2 = TYPE_FIELDS (oldt);
820                      f1 && f2; f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2))
821                   {
822                     unsigned ix;
823                     gcc_assert (f1 != f2 && DECL_NAME (f1) == DECL_NAME (f2));
824                     if (!streamer_tree_cache_lookup (cache, f2, &ix))
825                       gcc_unreachable ();
826                     /* If we're going to replace an element which we'd
827                        still visit in the next iterations, we wouldn't
828                        handle it, so do it here.  We do have to handle it
829                        even though the field_decl itself will be removed,
830                        as it could refer to e.g. integer_cst which we
831                        wouldn't reach via any other way, hence they
832                        (and their type) would stay uncollected.  */
833                     /* ???  We should rather make sure to replace all
834                        references to f2 with f1.  That means handling
835                        COMPONENT_REFs and CONSTRUCTOR elements in
836                        lto_fixup_types and special-case the field-decl
837                        operand handling.  */
838                     if (ix < i)
839                       lto_fixup_types (f2);
840                     streamer_tree_cache_insert_at (cache, f1, ix);
841                   }
842             }
843
844           /* If we found a tree that is equal to oldt replace it in the
845              cache, so that further users (in the various LTO sections)
846              make use of it.  */
847           streamer_tree_cache_insert_at (cache, t, i);
848         }
849     }
850
851   /* Finally compute the canonical type of all TREE_TYPEs and register
852      VAR_DECL and FUNCTION_DECL nodes in the symbol table.
853      From this point there are no longer any types with
854      TYPE_STRUCTURAL_EQUALITY_P and its type-based alias problems.
855      This step requires the TYPE_POINTER_TO lists being present, so
856      make sure it is done last.  */
857   for (i = len; i-- > from;)
858     {
859       tree t = VEC_index (tree, cache->nodes, i);
860       if (t == NULL_TREE)
861         continue;
862
863       if (TREE_CODE (t) == VAR_DECL)
864         lto_register_var_decl_in_symtab (data_in, t);
865       else if (TREE_CODE (t) == FUNCTION_DECL && !DECL_BUILT_IN (t))
866         lto_register_function_decl_in_symtab (data_in, t);
867       else if (TYPE_P (t) && !TYPE_CANONICAL (t))
868         TYPE_CANONICAL (t) = gimple_register_canonical_type (t);
869     }
870 }
871
872
873 /* Read all the symbols from buffer DATA, using descriptors in DECL_DATA.
874    RESOLUTIONS is the set of symbols picked by the linker (read from the
875    resolution file when the linker plugin is being used).  */
876
877 static void
878 lto_read_decls (struct lto_file_decl_data *decl_data, const void *data,
879                 VEC(ld_plugin_symbol_resolution_t,heap) *resolutions)
880 {
881   const struct lto_decl_header *header = (const struct lto_decl_header *) data;
882   const int32_t decl_offset = sizeof (struct lto_decl_header);
883   const int32_t main_offset = decl_offset + header->decl_state_size;
884   const int32_t string_offset = main_offset + header->main_size;
885   struct lto_input_block ib_main;
886   struct data_in *data_in;
887   unsigned int i;
888   const uint32_t *data_ptr, *data_end;
889   uint32_t num_decl_states;
890
891   LTO_INIT_INPUT_BLOCK (ib_main, (const char *) data + main_offset, 0,
892                         header->main_size);
893
894   data_in = lto_data_in_create (decl_data, (const char *) data + string_offset,
895                                 header->string_size, resolutions);
896
897   /* Read the global declarations and types.  */
898   while (ib_main.p < ib_main.len)
899     {
900       tree t;
901       unsigned from = VEC_length (tree, data_in->reader_cache->nodes);
902       t = stream_read_tree (&ib_main, data_in);
903       gcc_assert (t && ib_main.p <= ib_main.len);
904       uniquify_nodes (data_in, from);
905     }
906
907   /* Read in lto_in_decl_state objects.  */
908   data_ptr = (const uint32_t *) ((const char*) data + decl_offset); 
909   data_end =
910      (const uint32_t *) ((const char*) data_ptr + header->decl_state_size);
911   num_decl_states = *data_ptr++;
912   
913   gcc_assert (num_decl_states > 0);
914   decl_data->global_decl_state = lto_new_in_decl_state ();
915   data_ptr = lto_read_in_decl_state (data_in, data_ptr,
916                                      decl_data->global_decl_state);
917
918   /* Read in per-function decl states and enter them in hash table.  */
919   decl_data->function_decl_states =
920     htab_create_ggc (37, lto_hash_in_decl_state, lto_eq_in_decl_state, NULL);
921
922   for (i = 1; i < num_decl_states; i++)
923     {
924       struct lto_in_decl_state *state = lto_new_in_decl_state ();
925       void **slot;
926
927       data_ptr = lto_read_in_decl_state (data_in, data_ptr, state);
928       slot = htab_find_slot (decl_data->function_decl_states, state, INSERT);
929       gcc_assert (*slot == NULL);
930       *slot = state;
931     }
932
933   if (data_ptr != data_end)
934     internal_error ("bytecode stream: garbage at the end of symbols section");
935   
936   /* Set the current decl state to be the global state. */
937   decl_data->current_decl_state = decl_data->global_decl_state;
938
939   lto_data_in_delete (data_in);
940 }
941
942 /* strtoll is not portable. */
943 int64_t
944 lto_parse_hex (const char *p) {
945   uint64_t ret = 0;
946   for (; *p != '\0'; ++p)
947     {
948       char c = *p;
949       unsigned char part;
950       ret <<= 4;
951       if (c >= '0' && c <= '9')
952         part = c - '0';
953       else if (c >= 'a' && c <= 'f')
954         part = c - 'a' + 10;
955       else if (c >= 'A' && c <= 'F')
956         part = c - 'A' + 10;
957       else
958         internal_error ("could not parse hex number");
959       ret |= part;
960     }
961   return ret;
962 }
963
964 /* Read resolution for file named FILE_NAME. The resolution is read from
965    RESOLUTION. */
966
967 static void
968 lto_resolution_read (splay_tree file_ids, FILE *resolution, lto_file *file)
969 {
970   /* We require that objects in the resolution file are in the same
971      order as the lto1 command line. */
972   unsigned int name_len;
973   char *obj_name;
974   unsigned int num_symbols;
975   unsigned int i;
976   struct lto_file_decl_data *file_data;
977   unsigned max_index = 0;
978   splay_tree_node nd = NULL; 
979
980   if (!resolution)
981     return;
982
983   name_len = strlen (file->filename);
984   obj_name = XNEWVEC (char, name_len + 1);
985   fscanf (resolution, " ");   /* Read white space. */
986
987   fread (obj_name, sizeof (char), name_len, resolution);
988   obj_name[name_len] = '\0';
989   if (filename_cmp (obj_name, file->filename) != 0)
990     internal_error ("unexpected file name %s in linker resolution file. "
991                     "Expected %s", obj_name, file->filename);
992   if (file->offset != 0)
993     {
994       int t;
995       char offset_p[17];
996       int64_t offset;
997       t = fscanf (resolution, "@0x%16s", offset_p);
998       if (t != 1)
999         internal_error ("could not parse file offset");
1000       offset = lto_parse_hex (offset_p);
1001       if (offset != file->offset)
1002         internal_error ("unexpected offset");
1003     }
1004
1005   free (obj_name);
1006
1007   fscanf (resolution, "%u", &num_symbols);
1008
1009   for (i = 0; i < num_symbols; i++)
1010     {
1011       int t;
1012       unsigned index;
1013       unsigned HOST_WIDE_INT id;
1014       char r_str[27];
1015       enum ld_plugin_symbol_resolution r = (enum ld_plugin_symbol_resolution) 0;
1016       unsigned int j;
1017       unsigned int lto_resolution_str_len =
1018         sizeof (lto_resolution_str) / sizeof (char *);
1019
1020       t = fscanf (resolution, "%u " HOST_WIDE_INT_PRINT_HEX_PURE " %26s %*[^\n]\n", 
1021                   &index, &id, r_str);
1022       if (t != 3)
1023         internal_error ("invalid line in the resolution file");
1024       if (index > max_index)
1025         max_index = index;
1026
1027       for (j = 0; j < lto_resolution_str_len; j++)
1028         {
1029           if (strcmp (lto_resolution_str[j], r_str) == 0)
1030             {
1031               r = (enum ld_plugin_symbol_resolution) j;
1032               break;
1033             }
1034         }
1035       if (j == lto_resolution_str_len)
1036         internal_error ("invalid resolution in the resolution file");
1037
1038       if (!(nd && lto_splay_tree_id_equal_p (nd->key, id)))
1039         {
1040           nd = lto_splay_tree_lookup (file_ids, id);
1041           if (nd == NULL)
1042             internal_error ("resolution sub id " HOST_WIDE_INT_PRINT_HEX_PURE
1043                             " not in object file", id);
1044         }
1045
1046       file_data = (struct lto_file_decl_data *)nd->value;
1047       VEC_safe_grow_cleared (ld_plugin_symbol_resolution_t, heap, 
1048                              file_data->resolutions,
1049                              max_index + 1);
1050       VEC_replace (ld_plugin_symbol_resolution_t, 
1051                    file_data->resolutions, index, r);
1052     }
1053 }
1054
1055 /* Is the name for a id'ed LTO section? */
1056
1057 static int 
1058 lto_section_with_id (const char *name, unsigned HOST_WIDE_INT *id)
1059 {
1060   const char *s;
1061
1062   if (strncmp (name, LTO_SECTION_NAME_PREFIX, strlen (LTO_SECTION_NAME_PREFIX)))
1063     return 0;
1064   s = strrchr (name, '.');
1065   return s && sscanf (s, "." HOST_WIDE_INT_PRINT_HEX_PURE, id) == 1;
1066 }
1067
1068 /* Create file_data of each sub file id */
1069
1070 static int 
1071 create_subid_section_table (void **slot, void *data)
1072 {
1073   struct lto_section_slot s_slot, *new_slot;
1074   struct lto_section_slot *ls = *(struct lto_section_slot **)slot;
1075   splay_tree file_ids = (splay_tree)data;
1076   unsigned HOST_WIDE_INT id;
1077   splay_tree_node nd;
1078   void **hash_slot;
1079   char *new_name;
1080   struct lto_file_decl_data *file_data;
1081
1082   if (!lto_section_with_id (ls->name, &id))
1083     return 1;
1084   
1085   /* Find hash table of sub module id */
1086   nd = lto_splay_tree_lookup (file_ids, id);
1087   if (nd != NULL)
1088     {
1089       file_data = (struct lto_file_decl_data *)nd->value;
1090     }
1091   else
1092     {
1093       file_data = ggc_alloc_lto_file_decl_data ();
1094       memset(file_data, 0, sizeof (struct lto_file_decl_data));
1095       file_data->id = id;
1096       file_data->section_hash_table = lto_obj_create_section_hash_table ();;
1097       lto_splay_tree_insert (file_ids, id, file_data);
1098     }
1099
1100   /* Copy section into sub module hash table */
1101   new_name = XDUPVEC (char, ls->name, strlen (ls->name) + 1);
1102   s_slot.name = new_name;
1103   hash_slot = htab_find_slot (file_data->section_hash_table, &s_slot, INSERT);
1104   gcc_assert (*hash_slot == NULL);
1105
1106   new_slot = XDUP (struct lto_section_slot, ls);
1107   new_slot->name = new_name;
1108   *hash_slot = new_slot;
1109   return 1;
1110 }
1111
1112 /* Read declarations and other initializations for a FILE_DATA. */
1113
1114 static void
1115 lto_file_finalize (struct lto_file_decl_data *file_data, lto_file *file)
1116 {
1117   const char *data;
1118   size_t len;
1119
1120   file_data->renaming_hash_table = lto_create_renaming_table ();
1121   file_data->file_name = file->filename;
1122   data = lto_get_section_data (file_data, LTO_section_decls, NULL, &len);
1123   if (data == NULL)
1124     {
1125       internal_error ("cannot read LTO decls from %s", file_data->file_name);
1126       return;
1127     }
1128   lto_read_decls (file_data, data, file_data->resolutions);
1129   lto_free_section_data (file_data, LTO_section_decls, NULL, data, len);
1130 }
1131
1132 struct lwstate
1133 {
1134   lto_file *file;
1135   struct lto_file_decl_data **file_data;
1136   int *count;
1137 };
1138
1139 /* Traverse ids and create a list of file_datas out of it. */      
1140
1141 static int lto_create_files_from_ids (splay_tree_node node, void *data)
1142 {
1143   struct lwstate *lw = (struct lwstate *)data;
1144   struct lto_file_decl_data *file_data = (struct lto_file_decl_data *)node->value;
1145
1146   lto_file_finalize (file_data, lw->file);
1147   if (cgraph_dump_file)
1148     fprintf (cgraph_dump_file, "Creating file %s with sub id " HOST_WIDE_INT_PRINT_HEX "\n", 
1149              file_data->file_name, file_data->id);
1150   file_data->next = *lw->file_data;
1151   *lw->file_data = file_data;
1152   (*lw->count)++;
1153   return 0;
1154 }
1155
1156 /* Generate a TREE representation for all types and external decls
1157    entities in FILE.  
1158
1159    Read all of the globals out of the file.  Then read the cgraph
1160    and process the .o index into the cgraph nodes so that it can open
1161    the .o file to load the functions and ipa information.   */
1162
1163 static struct lto_file_decl_data *
1164 lto_file_read (lto_file *file, FILE *resolution_file, int *count)
1165 {
1166   struct lto_file_decl_data *file_data = NULL;
1167   splay_tree file_ids;
1168   htab_t section_hash_table;
1169   struct lwstate state;
1170   
1171   section_hash_table = lto_obj_build_section_table (file);
1172
1173   /* Find all sub modules in the object and put their sections into new hash
1174      tables in a splay tree. */
1175   file_ids = lto_splay_tree_new ();
1176   htab_traverse (section_hash_table, create_subid_section_table, file_ids);
1177   
1178   /* Add resolutions to file ids */
1179   lto_resolution_read (file_ids, resolution_file, file);
1180
1181   /* Finalize each lto file for each submodule in the merged object
1182      and create list for returning. */
1183   state.file = file;
1184   state.file_data = &file_data;
1185   state.count = count;
1186   splay_tree_foreach (file_ids, lto_create_files_from_ids, &state);
1187     
1188   splay_tree_delete (file_ids);
1189   htab_delete (section_hash_table);
1190
1191   return file_data;
1192 }
1193
1194 #if HAVE_MMAP_FILE && HAVE_SYSCONF && defined _SC_PAGE_SIZE
1195 #define LTO_MMAP_IO 1
1196 #endif
1197
1198 #if LTO_MMAP_IO
1199 /* Page size of machine is used for mmap and munmap calls.  */
1200 static size_t page_mask;
1201 #endif
1202
1203 /* Get the section data of length LEN from FILENAME starting at
1204    OFFSET.  The data segment must be freed by the caller when the
1205    caller is finished.  Returns NULL if all was not well.  */
1206
1207 static char *
1208 lto_read_section_data (struct lto_file_decl_data *file_data,
1209                        intptr_t offset, size_t len)
1210 {
1211   char *result;
1212   static int fd = -1;
1213   static char *fd_name;
1214 #if LTO_MMAP_IO
1215   intptr_t computed_len;
1216   intptr_t computed_offset;
1217   intptr_t diff;
1218 #endif
1219
1220   /* Keep a single-entry file-descriptor cache.  The last file we
1221      touched will get closed at exit.
1222      ???  Eventually we want to add a more sophisticated larger cache
1223      or rather fix function body streaming to not stream them in
1224      practically random order.  */
1225   if (fd != -1
1226       && filename_cmp (fd_name, file_data->file_name) != 0)
1227     {
1228       free (fd_name);
1229       close (fd);
1230       fd = -1;
1231     }
1232   if (fd == -1)
1233     {
1234       fd = open (file_data->file_name, O_RDONLY|O_BINARY);
1235       if (fd == -1)
1236         return NULL;
1237       fd_name = xstrdup (file_data->file_name);
1238     }
1239
1240 #if LTO_MMAP_IO
1241   if (!page_mask)
1242     {
1243       size_t page_size = sysconf (_SC_PAGE_SIZE);
1244       page_mask = ~(page_size - 1);
1245     }
1246
1247   computed_offset = offset & page_mask;
1248   diff = offset - computed_offset;
1249   computed_len = len + diff;
1250
1251   result = (char *) mmap (NULL, computed_len, PROT_READ, MAP_PRIVATE,
1252                           fd, computed_offset);
1253   if (result == MAP_FAILED)
1254     return NULL;
1255
1256   return result + diff;
1257 #else
1258   result = (char *) xmalloc (len);
1259   if (lseek (fd, offset, SEEK_SET) != offset
1260       || read (fd, result, len) != (ssize_t) len)
1261     {
1262       free (result);
1263       result = NULL;
1264     }
1265 #ifdef __MINGW32__
1266   /* Native windows doesn't supports delayed unlink on opened file. So
1267      we close file here again. This produces higher I/O load, but at least
1268      it prevents to have dangling file handles preventing unlink.  */
1269   free (fd_name);
1270   fd_name = NULL;
1271   close (fd);
1272   fd = -1;
1273 #endif
1274   return result;
1275 #endif
1276 }    
1277
1278
1279 /* Get the section data from FILE_DATA of SECTION_TYPE with NAME.
1280    NAME will be NULL unless the section type is for a function
1281    body.  */
1282
1283 static const char *
1284 get_section_data (struct lto_file_decl_data *file_data,
1285                       enum lto_section_type section_type,
1286                       const char *name,
1287                       size_t *len)
1288 {
1289   htab_t section_hash_table = file_data->section_hash_table;
1290   struct lto_section_slot *f_slot;
1291   struct lto_section_slot s_slot;
1292   const char *section_name = lto_get_section_name (section_type, name, file_data);
1293   char *data = NULL;
1294
1295   *len = 0;
1296   s_slot.name = section_name;
1297   f_slot = (struct lto_section_slot *) htab_find (section_hash_table, &s_slot);
1298   if (f_slot)
1299     {
1300       data = lto_read_section_data (file_data, f_slot->start, f_slot->len);
1301       *len = f_slot->len;
1302     }
1303
1304   free (CONST_CAST (char *, section_name));
1305   return data;
1306 }
1307
1308
1309 /* Free the section data from FILE_DATA of SECTION_TYPE with NAME that
1310    starts at OFFSET and has LEN bytes.  */
1311
1312 static void
1313 free_section_data (struct lto_file_decl_data *file_data ATTRIBUTE_UNUSED,
1314                    enum lto_section_type section_type ATTRIBUTE_UNUSED,
1315                    const char *name ATTRIBUTE_UNUSED,
1316                    const char *offset, size_t len ATTRIBUTE_UNUSED)
1317 {
1318 #if LTO_MMAP_IO
1319   intptr_t computed_len;
1320   intptr_t computed_offset;
1321   intptr_t diff;
1322 #endif
1323
1324 #if LTO_MMAP_IO
1325   computed_offset = ((intptr_t) offset) & page_mask;
1326   diff = (intptr_t) offset - computed_offset;
1327   computed_len = len + diff;
1328
1329   munmap ((caddr_t) computed_offset, computed_len);
1330 #else
1331   free (CONST_CAST(char *, offset));
1332 #endif
1333 }
1334
1335 /* Structure describing ltrans partitions.  */
1336
1337 struct ltrans_partition_def
1338 {
1339   cgraph_node_set cgraph_set;
1340   varpool_node_set varpool_set;
1341   const char * name;
1342   int insns;
1343 };
1344
1345 typedef struct ltrans_partition_def *ltrans_partition;
1346 DEF_VEC_P(ltrans_partition);
1347 DEF_VEC_ALLOC_P(ltrans_partition,heap);
1348
1349 static VEC(ltrans_partition, heap) *ltrans_partitions;
1350
1351 static void add_cgraph_node_to_partition (ltrans_partition part, struct cgraph_node *node);
1352 static void add_varpool_node_to_partition (ltrans_partition part, struct varpool_node *vnode);
1353
1354 /* Create new partition with name NAME.  */
1355 static ltrans_partition
1356 new_partition (const char *name)
1357 {
1358   ltrans_partition part = XCNEW (struct ltrans_partition_def);
1359   part->cgraph_set = cgraph_node_set_new ();
1360   part->varpool_set = varpool_node_set_new ();
1361   part->name = name;
1362   part->insns = 0;
1363   VEC_safe_push (ltrans_partition, heap, ltrans_partitions, part);
1364   return part;
1365 }
1366
1367 /* Free memory used by ltrans datastructures.  */
1368 static void
1369 free_ltrans_partitions (void)
1370 {
1371   unsigned int idx;
1372   ltrans_partition part;
1373   for (idx = 0; VEC_iterate (ltrans_partition, ltrans_partitions, idx, part); idx++)
1374     {
1375       free_cgraph_node_set (part->cgraph_set);
1376       free (part);
1377     }
1378   VEC_free (ltrans_partition, heap, ltrans_partitions);
1379 }
1380
1381 /* See all references that go to comdat objects and bring them into partition too.  */
1382 static void
1383 add_references_to_partition (ltrans_partition part, struct ipa_ref_list *refs)
1384 {
1385   int i;
1386   struct ipa_ref *ref;
1387   for (i = 0; ipa_ref_list_reference_iterate (refs, i, ref); i++)
1388     {
1389       if (ref->refered_type == IPA_REF_CGRAPH
1390           && DECL_COMDAT (cgraph_function_node (ipa_ref_node (ref), NULL)->decl)
1391           && !cgraph_node_in_set_p (ipa_ref_node (ref), part->cgraph_set))
1392         add_cgraph_node_to_partition (part, ipa_ref_node (ref));
1393       else
1394         if (ref->refered_type == IPA_REF_VARPOOL
1395             && DECL_COMDAT (ipa_ref_varpool_node (ref)->decl)
1396             && !varpool_node_in_set_p (ipa_ref_varpool_node (ref), part->varpool_set))
1397           add_varpool_node_to_partition (part, ipa_ref_varpool_node (ref));
1398     }
1399 }
1400
1401 /* Worker for add_cgraph_node_to_partition.  */
1402
1403 static bool
1404 add_cgraph_node_to_partition_1 (struct cgraph_node *node, void *data)
1405 {
1406   ltrans_partition part = (ltrans_partition) data;
1407
1408   /* non-COMDAT aliases of COMDAT functions needs to be output just once.  */
1409   if (!DECL_COMDAT (node->decl)
1410       && !node->global.inlined_to
1411       && node->aux)
1412     {
1413       gcc_assert (node->thunk.thunk_p || node->alias);
1414       return false;
1415     }
1416
1417   if (node->aux)
1418     {
1419       node->in_other_partition = 1;
1420       if (cgraph_dump_file)
1421         fprintf (cgraph_dump_file, "Node %s/%i now used in multiple partitions\n",
1422                  cgraph_node_name (node), node->uid);
1423     }
1424   node->aux = (void *)((size_t)node->aux + 1);
1425   cgraph_node_set_add (part->cgraph_set, node);
1426   return false;
1427 }
1428
1429 /* Add NODE to partition as well as the inline callees and referred comdats into partition PART. */
1430
1431 static void
1432 add_cgraph_node_to_partition (ltrans_partition part, struct cgraph_node *node)
1433 {
1434   struct cgraph_edge *e;
1435   cgraph_node_set_iterator csi;
1436   struct cgraph_node *n;
1437
1438   /* We always decide on functions, not associated thunks and aliases.  */
1439   node = cgraph_function_node (node, NULL);
1440
1441   /* If NODE is already there, we have nothing to do.  */
1442   csi = cgraph_node_set_find (part->cgraph_set, node);
1443   if (!csi_end_p (csi))
1444     return;
1445
1446   cgraph_for_node_thunks_and_aliases (node, add_cgraph_node_to_partition_1, part, true);
1447
1448   part->insns += inline_summary (node)->self_size;
1449
1450
1451   cgraph_node_set_add (part->cgraph_set, node);
1452
1453   for (e = node->callees; e; e = e->next_callee)
1454     if ((!e->inline_failed
1455          || DECL_COMDAT (cgraph_function_node (e->callee, NULL)->decl))
1456         && !cgraph_node_in_set_p (e->callee, part->cgraph_set))
1457       add_cgraph_node_to_partition (part, e->callee);
1458
1459   add_references_to_partition (part, &node->ref_list);
1460
1461   if (node->same_comdat_group)
1462     for (n = node->same_comdat_group; n != node; n = n->same_comdat_group)
1463       add_cgraph_node_to_partition (part, n);
1464 }
1465
1466 /* Add VNODE to partition as well as comdat references partition PART. */
1467
1468 static void
1469 add_varpool_node_to_partition (ltrans_partition part, struct varpool_node *vnode)
1470 {
1471   varpool_node_set_iterator vsi;
1472
1473   /* If NODE is already there, we have nothing to do.  */
1474   vsi = varpool_node_set_find (part->varpool_set, vnode);
1475   if (!vsi_end_p (vsi))
1476     return;
1477
1478   varpool_node_set_add (part->varpool_set, vnode);
1479
1480   if (vnode->aux)
1481     {
1482       vnode->in_other_partition = 1;
1483       if (cgraph_dump_file)
1484         fprintf (cgraph_dump_file, "Varpool node %s now used in multiple partitions\n",
1485                  varpool_node_name (vnode));
1486     }
1487   vnode->aux = (void *)((size_t)vnode->aux + 1);
1488
1489   add_references_to_partition (part, &vnode->ref_list);
1490
1491   if (vnode->same_comdat_group
1492       && !varpool_node_in_set_p (vnode->same_comdat_group, part->varpool_set))
1493     add_varpool_node_to_partition (part, vnode->same_comdat_group);
1494 }
1495
1496 /* Undo all additions until number of cgraph nodes in PARITION is N_CGRAPH_NODES
1497    and number of varpool nodes is N_VARPOOL_NODES.  */
1498
1499 static void
1500 undo_partition (ltrans_partition partition, unsigned int n_cgraph_nodes,
1501                 unsigned int n_varpool_nodes)
1502 {
1503   while (VEC_length (cgraph_node_ptr, partition->cgraph_set->nodes) >
1504          n_cgraph_nodes)
1505     {
1506       struct cgraph_node *node = VEC_index (cgraph_node_ptr,
1507                                             partition->cgraph_set->nodes,
1508                                             n_cgraph_nodes);
1509       partition->insns -= inline_summary (node)->self_size;
1510       cgraph_node_set_remove (partition->cgraph_set, node);
1511       node->aux = (void *)((size_t)node->aux - 1);
1512     }
1513   while (VEC_length (varpool_node_ptr, partition->varpool_set->nodes) >
1514          n_varpool_nodes)
1515     {
1516       struct varpool_node *node = VEC_index (varpool_node_ptr,
1517                                              partition->varpool_set->nodes,
1518                                              n_varpool_nodes);
1519       varpool_node_set_remove (partition->varpool_set, node);
1520       node->aux = (void *)((size_t)node->aux - 1);
1521     }
1522 }
1523
1524 /* Return true if NODE should be partitioned.
1525    This means that partitioning algorithm should put NODE into one of partitions.
1526    This apply to most functions with bodies.  Functions that are not partitions
1527    are put into every unit needing them.  This is the case of i.e. COMDATs.  */
1528
1529 static bool
1530 partition_cgraph_node_p (struct cgraph_node *node)
1531 {
1532   /* We will get proper partition based on function they are inlined to.  */
1533   if (node->global.inlined_to)
1534     return false;
1535   /* Nodes without a body do not need partitioning.  */
1536   if (!node->analyzed)
1537     return false;
1538   /* Extern inlines and comdat are always only in partitions they are needed.  */
1539   if (DECL_EXTERNAL (node->decl)
1540       || (DECL_COMDAT (node->decl)
1541           && !cgraph_used_from_object_file_p (node)))
1542     return false;
1543   if (lookup_attribute ("weakref", DECL_ATTRIBUTES (node->decl)))
1544     return false;
1545   return true;
1546 }
1547
1548 /* Return true if VNODE should be partitioned. 
1549    This means that partitioning algorithm should put VNODE into one of partitions. */
1550
1551 static bool
1552 partition_varpool_node_p (struct varpool_node *vnode)
1553 {
1554   if (vnode->alias || !vnode->needed)
1555     return false;
1556   /* Constant pool and comdat are always only in partitions they are needed.  */
1557   if (DECL_IN_CONSTANT_POOL (vnode->decl)
1558       || (DECL_COMDAT (vnode->decl)
1559           && !vnode->force_output
1560           && !varpool_used_from_object_file_p (vnode)))
1561     return false;
1562   if (lookup_attribute ("weakref", DECL_ATTRIBUTES (vnode->decl)))
1563     return false;
1564   return true;
1565 }
1566
1567 /* Group cgrah nodes by input files.  This is used mainly for testing
1568    right now.  */
1569
1570 static void
1571 lto_1_to_1_map (void)
1572 {
1573   struct cgraph_node *node;
1574   struct varpool_node *vnode;
1575   struct lto_file_decl_data *file_data;
1576   struct pointer_map_t *pmap;
1577   ltrans_partition partition;
1578   void **slot;
1579   int npartitions = 0;
1580
1581   timevar_push (TV_WHOPR_WPA);
1582
1583   pmap = pointer_map_create ();
1584
1585   for (node = cgraph_nodes; node; node = node->next)
1586     {
1587       if (!partition_cgraph_node_p (node)
1588           || node->aux)
1589         continue;
1590
1591       file_data = node->local.lto_file_data;
1592
1593       if (file_data)
1594         {
1595           slot = pointer_map_contains (pmap, file_data);
1596           if (slot)
1597             partition = (ltrans_partition) *slot;
1598           else
1599             {
1600               partition = new_partition (file_data->file_name);
1601               slot = pointer_map_insert (pmap, file_data);
1602               *slot = partition;
1603               npartitions++;
1604             }
1605         }
1606       else if (!file_data
1607                && VEC_length (ltrans_partition, ltrans_partitions))
1608         partition = VEC_index (ltrans_partition, ltrans_partitions, 0);
1609       else
1610         {
1611           partition = new_partition ("");
1612           slot = pointer_map_insert (pmap, NULL);
1613           *slot = partition;
1614           npartitions++;
1615         }
1616
1617       add_cgraph_node_to_partition (partition, node);
1618     }
1619
1620   for (vnode = varpool_nodes; vnode; vnode = vnode->next)
1621     {
1622       if (!partition_varpool_node_p (vnode)
1623           || vnode->aux)
1624         continue;
1625       file_data = vnode->lto_file_data;
1626       slot = pointer_map_contains (pmap, file_data);
1627       if (slot)
1628         partition = (ltrans_partition) *slot;
1629       else
1630         {
1631           partition = new_partition (file_data->file_name);
1632           slot = pointer_map_insert (pmap, file_data);
1633           *slot = partition;
1634           npartitions++;
1635         }
1636
1637       add_varpool_node_to_partition (partition, vnode);
1638     }
1639   for (node = cgraph_nodes; node; node = node->next)
1640     node->aux = NULL;
1641   for (vnode = varpool_nodes; vnode; vnode = vnode->next)
1642     vnode->aux = NULL;
1643
1644   /* If the cgraph is empty, create one cgraph node set so that there is still
1645      an output file for any variables that need to be exported in a DSO.  */
1646   if (!npartitions)
1647     new_partition ("empty");
1648
1649   pointer_map_destroy (pmap);
1650
1651   timevar_pop (TV_WHOPR_WPA);
1652
1653   lto_stats.num_cgraph_partitions += VEC_length (ltrans_partition, 
1654                                                  ltrans_partitions);
1655 }
1656
1657
1658 /* Group cgraph nodes into equally-sized partitions.
1659
1660    The partitioning algorithm is simple: nodes are taken in predefined order.
1661    The order corresponds to the order we want functions to have in the final
1662    output.  In the future this will be given by function reordering pass, but
1663    at the moment we use the topological order, which is a good approximation.
1664
1665    The goal is to partition this linear order into intervals (partitions) so
1666    that all the partitions have approximately the same size and the number of
1667    callgraph or IPA reference edges crossing boundaries is minimal.
1668
1669    This is a lot faster (O(n) in size of callgraph) than algorithms doing
1670    priority-based graph clustering that are generally O(n^2) and, since
1671    WHOPR is designed to make things go well across partitions, it leads
1672    to good results.
1673
1674    We compute the expected size of a partition as:
1675
1676      max (total_size / lto_partitions, min_partition_size)
1677
1678    We use dynamic expected size of partition so small programs are partitioned
1679    into enough partitions to allow use of multiple CPUs, while large programs
1680    are not partitioned too much.  Creating too many partitions significantly
1681    increases the streaming overhead.
1682
1683    In the future, we would like to bound the maximal size of partitions so as
1684    to prevent the LTRANS stage from consuming too much memory.  At the moment,
1685    however, the WPA stage is the most memory intensive for large benchmarks,
1686    since too many types and declarations are read into memory.
1687
1688    The function implements a simple greedy algorithm.  Nodes are being added
1689    to the current partition until after 3/4 of the expected partition size is
1690    reached.  Past this threshold, we keep track of boundary size (number of
1691    edges going to other partitions) and continue adding functions until after
1692    the current partition has grown to twice the expected partition size.  Then
1693    the process is undone to the point where the minimal ratio of boundary size
1694    and in-partition calls was reached.  */
1695
1696 static void
1697 lto_balanced_map (void)
1698 {
1699   int n_nodes = 0;
1700   struct cgraph_node **postorder =
1701     XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
1702   struct cgraph_node **order = XNEWVEC (struct cgraph_node *, cgraph_max_uid);
1703   int i, postorder_len;
1704   struct cgraph_node *node;
1705   int total_size = 0, best_total_size = 0;
1706   int partition_size;
1707   ltrans_partition partition;
1708   unsigned int last_visited_cgraph_node = 0, last_visited_varpool_node = 0;
1709   struct varpool_node *vnode;
1710   int cost = 0, internal = 0;
1711   int best_n_nodes = 0, best_n_varpool_nodes = 0, best_i = 0, best_cost =
1712     INT_MAX, best_internal = 0;
1713   int npartitions;
1714
1715   for (vnode = varpool_nodes; vnode; vnode = vnode->next)
1716     gcc_assert (!vnode->aux);
1717   /* Until we have better ordering facility, use toplogical order.
1718      Include only nodes we will partition and compute estimate of program
1719      size.  Note that since nodes that are not partitioned might be put into
1720      multiple partitions, this is just an estimate of real size.  This is why
1721      we keep partition_size updated after every partition is finalized.  */
1722   postorder_len = ipa_reverse_postorder (postorder);
1723   for (i = 0; i < postorder_len; i++)
1724     {
1725       node = postorder[i];
1726       if (partition_cgraph_node_p (node))
1727         {
1728           order[n_nodes++] = node;
1729           total_size += inline_summary (node)->size;
1730         }
1731     }
1732   free (postorder);
1733
1734   /* Compute partition size and create the first partition.  */
1735   partition_size = total_size / PARAM_VALUE (PARAM_LTO_PARTITIONS);
1736   if (partition_size < PARAM_VALUE (MIN_PARTITION_SIZE))
1737     partition_size = PARAM_VALUE (MIN_PARTITION_SIZE);
1738   npartitions = 1;
1739   partition = new_partition ("");
1740   if (cgraph_dump_file)
1741     fprintf (cgraph_dump_file, "Total unit size: %i, partition size: %i\n",
1742              total_size, partition_size);
1743
1744   for (i = 0; i < n_nodes; i++)
1745     {
1746       if (order[i]->aux)
1747         continue;
1748       add_cgraph_node_to_partition (partition, order[i]);
1749       total_size -= inline_summary (order[i])->size;
1750
1751       /* Once we added a new node to the partition, we also want to add
1752          all referenced variables unless they was already added into some
1753          earlier partition.
1754          add_cgraph_node_to_partition adds possibly multiple nodes and
1755          variables that are needed to satisfy needs of ORDER[i].
1756          We remember last visited cgraph and varpool node from last iteration
1757          of outer loop that allows us to process every new addition. 
1758
1759          At the same time we compute size of the boundary into COST.  Every
1760          callgraph or IPA reference edge leaving the partition contributes into
1761          COST.  Every edge inside partition was earlier computed as one leaving
1762          it and thus we need to subtract it from COST.  */
1763       while (last_visited_cgraph_node <
1764              VEC_length (cgraph_node_ptr, partition->cgraph_set->nodes)
1765              || last_visited_varpool_node < VEC_length (varpool_node_ptr,
1766                                                         partition->varpool_set->
1767                                                         nodes))
1768         {
1769           struct ipa_ref_list *refs;
1770           int j;
1771           struct ipa_ref *ref;
1772           bool cgraph_p = false;
1773
1774           if (last_visited_cgraph_node <
1775               VEC_length (cgraph_node_ptr, partition->cgraph_set->nodes))
1776             {
1777               struct cgraph_edge *edge;
1778
1779               cgraph_p = true;
1780               node = VEC_index (cgraph_node_ptr, partition->cgraph_set->nodes,
1781                                 last_visited_cgraph_node);
1782               refs = &node->ref_list;
1783
1784               last_visited_cgraph_node++;
1785
1786               gcc_assert (node->analyzed);
1787
1788               /* Compute boundary cost of callgrpah edges.  */
1789               for (edge = node->callees; edge; edge = edge->next_callee)
1790                 if (edge->callee->analyzed)
1791                   {
1792                     int edge_cost = edge->frequency;
1793                     cgraph_node_set_iterator csi;
1794
1795                     if (!edge_cost)
1796                       edge_cost = 1;
1797                     gcc_assert (edge_cost > 0);
1798                     csi = cgraph_node_set_find (partition->cgraph_set, edge->callee);
1799                     if (!csi_end_p (csi)
1800                         && csi.index < last_visited_cgraph_node - 1)
1801                       cost -= edge_cost, internal+= edge_cost;
1802                     else
1803                       cost += edge_cost;
1804                   }
1805               for (edge = node->callers; edge; edge = edge->next_caller)
1806                 {
1807                   int edge_cost = edge->frequency;
1808                   cgraph_node_set_iterator csi;
1809
1810                   gcc_assert (edge->caller->analyzed);
1811                   if (!edge_cost)
1812                     edge_cost = 1;
1813                   gcc_assert (edge_cost > 0);
1814                   csi = cgraph_node_set_find (partition->cgraph_set, edge->caller);
1815                   if (!csi_end_p (csi)
1816                       && csi.index < last_visited_cgraph_node)
1817                     cost -= edge_cost;
1818                   else
1819                     cost += edge_cost;
1820                 }
1821             }
1822           else
1823             {
1824               refs =
1825                 &VEC_index (varpool_node_ptr, partition->varpool_set->nodes,
1826                             last_visited_varpool_node)->ref_list;
1827               last_visited_varpool_node++;
1828             }
1829
1830           /* Compute boundary cost of IPA REF edges and at the same time look into
1831              variables referenced from current partition and try to add them.  */
1832           for (j = 0; ipa_ref_list_reference_iterate (refs, j, ref); j++)
1833             if (ref->refered_type == IPA_REF_VARPOOL)
1834               {
1835                 varpool_node_set_iterator vsi;
1836
1837                 vnode = ipa_ref_varpool_node (ref);
1838                 if (!vnode->finalized)
1839                   continue;
1840                 if (!vnode->aux && partition_varpool_node_p (vnode))
1841                   add_varpool_node_to_partition (partition, vnode);
1842                 vsi = varpool_node_set_find (partition->varpool_set, vnode);
1843                 if (!vsi_end_p (vsi)
1844                     && vsi.index < last_visited_varpool_node - !cgraph_p)
1845                   cost--, internal++;
1846                 else
1847                   cost++;
1848               }
1849             else
1850               {
1851                 cgraph_node_set_iterator csi;
1852
1853                 node = ipa_ref_node (ref);
1854                 if (!node->analyzed)
1855                   continue;
1856                 csi = cgraph_node_set_find (partition->cgraph_set, node);
1857                 if (!csi_end_p (csi)
1858                     && csi.index < last_visited_cgraph_node - cgraph_p)
1859                   cost--, internal++;
1860                 else
1861                   cost++;
1862               }
1863           for (j = 0; ipa_ref_list_refering_iterate (refs, j, ref); j++)
1864             if (ref->refering_type == IPA_REF_VARPOOL)
1865               {
1866                 varpool_node_set_iterator vsi;
1867
1868                 vnode = ipa_ref_refering_varpool_node (ref);
1869                 gcc_assert (vnode->finalized);
1870                 if (!vnode->aux && partition_varpool_node_p (vnode))
1871                   add_varpool_node_to_partition (partition, vnode);
1872                 vsi = varpool_node_set_find (partition->varpool_set, vnode);
1873                 if (!vsi_end_p (vsi)
1874                     && vsi.index < last_visited_varpool_node)
1875                   cost--;
1876                 else
1877                   cost++;
1878               }
1879             else
1880               {
1881                 cgraph_node_set_iterator csi;
1882
1883                 node = ipa_ref_refering_node (ref);
1884                 gcc_assert (node->analyzed);
1885                 csi = cgraph_node_set_find (partition->cgraph_set, node);
1886                 if (!csi_end_p (csi)
1887                     && csi.index < last_visited_cgraph_node)
1888                   cost--;
1889                 else
1890                   cost++;
1891               }
1892         }
1893
1894       /* If the partition is large enough, start looking for smallest boundary cost.  */
1895       if (partition->insns < partition_size * 3 / 4
1896           || best_cost == INT_MAX
1897           || ((!cost 
1898                || (best_internal * (HOST_WIDE_INT) cost
1899                    > (internal * (HOST_WIDE_INT)best_cost)))
1900               && partition->insns < partition_size * 5 / 4))
1901         {
1902           best_cost = cost;
1903           best_internal = internal;
1904           best_i = i;
1905           best_n_nodes = VEC_length (cgraph_node_ptr,
1906                                      partition->cgraph_set->nodes);
1907           best_n_varpool_nodes = VEC_length (varpool_node_ptr,
1908                                              partition->varpool_set->nodes);
1909           best_total_size = total_size;
1910         }
1911       if (cgraph_dump_file)
1912         fprintf (cgraph_dump_file, "Step %i: added %s/%i, size %i, cost %i/%i best %i/%i, step %i\n", i,
1913                  cgraph_node_name (order[i]), order[i]->uid, partition->insns, cost, internal,
1914                  best_cost, best_internal, best_i);
1915       /* Partition is too large, unwind into step when best cost was reached and
1916          start new partition.  */
1917       if (partition->insns > 2 * partition_size)
1918         {
1919           if (best_i != i)
1920             {
1921               if (cgraph_dump_file)
1922                 fprintf (cgraph_dump_file, "Unwinding %i insertions to step %i\n",
1923                          i - best_i, best_i);
1924               undo_partition (partition, best_n_nodes, best_n_varpool_nodes);
1925             }
1926           i = best_i;
1927           /* When we are finished, avoid creating empty partition.  */
1928           while (i < n_nodes - 1 && order[i + 1]->aux)
1929             i++;
1930           if (i == n_nodes - 1)
1931             break;
1932           partition = new_partition ("");
1933           last_visited_cgraph_node = 0;
1934           last_visited_varpool_node = 0;
1935           total_size = best_total_size;
1936           cost = 0;
1937
1938           if (cgraph_dump_file)
1939             fprintf (cgraph_dump_file, "New partition\n");
1940           best_n_nodes = 0;
1941           best_n_varpool_nodes = 0;
1942           best_cost = INT_MAX;
1943
1944           /* Since the size of partitions is just approximate, update the size after
1945              we finished current one.  */
1946           if (npartitions < PARAM_VALUE (PARAM_LTO_PARTITIONS))
1947             partition_size = total_size
1948               / (PARAM_VALUE (PARAM_LTO_PARTITIONS) - npartitions);
1949           else
1950             partition_size = INT_MAX;
1951
1952           if (partition_size < PARAM_VALUE (MIN_PARTITION_SIZE))
1953             partition_size = PARAM_VALUE (MIN_PARTITION_SIZE);
1954           npartitions ++;
1955         }
1956     }
1957
1958   /* Varables that are not reachable from the code go into last partition.  */
1959   for (vnode = varpool_nodes; vnode; vnode = vnode->next)
1960     if (partition_varpool_node_p (vnode) && !vnode->aux)
1961       add_varpool_node_to_partition (partition, vnode);
1962   free (order);
1963 }
1964
1965 /* Promote variable VNODE to be static.  */
1966
1967 static bool
1968 promote_var (struct varpool_node *vnode)
1969 {
1970   if (TREE_PUBLIC (vnode->decl) || DECL_EXTERNAL (vnode->decl))
1971     return false;
1972   gcc_assert (flag_wpa);
1973   TREE_PUBLIC (vnode->decl) = 1;
1974   DECL_VISIBILITY (vnode->decl) = VISIBILITY_HIDDEN;
1975   DECL_VISIBILITY_SPECIFIED (vnode->decl) = true;
1976   if (cgraph_dump_file)
1977     fprintf (cgraph_dump_file,
1978             "Promoting var as hidden: %s\n", varpool_node_name (vnode));
1979   return true;
1980 }
1981
1982 /* Promote function NODE to be static.  */
1983
1984 static bool
1985 promote_fn (struct cgraph_node *node)
1986 {
1987   gcc_assert (flag_wpa);
1988   if (TREE_PUBLIC (node->decl) || DECL_EXTERNAL (node->decl))
1989     return false;
1990   TREE_PUBLIC (node->decl) = 1;
1991   DECL_VISIBILITY (node->decl) = VISIBILITY_HIDDEN;
1992   DECL_VISIBILITY_SPECIFIED (node->decl) = true;
1993   if (cgraph_dump_file)
1994     fprintf (cgraph_dump_file,
1995              "Promoting function as hidden: %s/%i\n",
1996              cgraph_node_name (node), node->uid);
1997   return true;
1998 }
1999
2000 /* Find out all static decls that need to be promoted to global because
2001    of cross file sharing.  This function must be run in the WPA mode after
2002    all inlinees are added.  */
2003
2004 static void
2005 lto_promote_cross_file_statics (void)
2006 {
2007   struct varpool_node *vnode;
2008   unsigned i, n_sets;
2009   cgraph_node_set set;
2010   varpool_node_set vset;
2011   cgraph_node_set_iterator csi;
2012   varpool_node_set_iterator vsi;
2013   VEC(varpool_node_ptr, heap) *promoted_initializers = NULL;
2014   struct pointer_set_t *inserted = pointer_set_create ();
2015
2016   gcc_assert (flag_wpa);
2017
2018   n_sets = VEC_length (ltrans_partition, ltrans_partitions);
2019   for (i = 0; i < n_sets; i++)
2020     {
2021       ltrans_partition part
2022         = VEC_index (ltrans_partition, ltrans_partitions, i);
2023       set = part->cgraph_set;
2024       vset = part->varpool_set;
2025
2026       /* If node called or referred to from other partition, it needs to be
2027          globalized.  */
2028       for (csi = csi_start (set); !csi_end_p (csi); csi_next (&csi))
2029         {
2030           struct cgraph_node *node = csi_node (csi);
2031           if (node->local.externally_visible)
2032             continue;
2033           if (node->global.inlined_to)
2034             continue;
2035           if ((!DECL_EXTERNAL (node->decl) && !DECL_COMDAT (node->decl))
2036               && (referenced_from_other_partition_p (&node->ref_list, set, vset)
2037                   || reachable_from_other_partition_p (node, set)))
2038             promote_fn (node);
2039         }
2040       for (vsi = vsi_start (vset); !vsi_end_p (vsi); vsi_next (&vsi))
2041         {
2042           vnode = vsi_node (vsi);
2043           /* Constant pool references use internal labels and thus can not
2044              be made global.  It is sensible to keep those ltrans local to
2045              allow better optimization.  */
2046           if (!DECL_IN_CONSTANT_POOL (vnode->decl) && !DECL_COMDAT (vnode->decl)
2047               && !vnode->externally_visible && vnode->analyzed
2048               && referenced_from_other_partition_p (&vnode->ref_list,
2049                                                     set, vset))
2050             promote_var (vnode);
2051         }
2052
2053       /* We export the initializer of a read-only var into each partition
2054          referencing the var.  Folding might take declarations from the
2055          initializer and use them, so everything referenced from the
2056          initializer can be accessed from this partition after folding.
2057
2058          This means that we need to promote all variables and functions
2059          referenced from all initializers of read-only vars referenced
2060          from this partition that are not in this partition.  This needs
2061          to be done recursively.  */
2062       for (vnode = varpool_nodes; vnode; vnode = vnode->next)
2063         if (const_value_known_p (vnode->decl)
2064             && DECL_INITIAL (vnode->decl)
2065             && !varpool_node_in_set_p (vnode, vset)
2066             && referenced_from_this_partition_p (&vnode->ref_list, set, vset)
2067             && !pointer_set_insert (inserted, vnode))
2068         VEC_safe_push (varpool_node_ptr, heap, promoted_initializers, vnode);
2069
2070       while (!VEC_empty (varpool_node_ptr, promoted_initializers))
2071         {
2072           int i;
2073           struct ipa_ref *ref;
2074
2075           vnode = VEC_pop (varpool_node_ptr, promoted_initializers);
2076           for (i = 0;
2077                ipa_ref_list_reference_iterate (&vnode->ref_list, i, ref);
2078                i++)
2079             {
2080               if (ref->refered_type == IPA_REF_CGRAPH)
2081                 {
2082                   struct cgraph_node *n = ipa_ref_node (ref);
2083                   gcc_assert (!n->global.inlined_to);
2084                   if (!n->local.externally_visible
2085                       && !cgraph_node_in_set_p (n, set))
2086                     promote_fn (n);
2087                 }
2088               else
2089                 {
2090                   struct varpool_node *v = ipa_ref_varpool_node (ref);
2091                   if (varpool_node_in_set_p (v, vset))
2092                     continue;
2093
2094                   /* Constant pool references use internal labels and thus
2095                      cannot be made global.  It is sensible to keep those
2096                      ltrans local to allow better optimization.  */
2097                   if (DECL_IN_CONSTANT_POOL (v->decl))
2098                     {
2099                       if (!pointer_set_insert (inserted, vnode))
2100                         VEC_safe_push (varpool_node_ptr, heap,
2101                                        promoted_initializers, v);
2102                     }
2103                   else if (!v->externally_visible && v->analyzed)
2104                     {
2105                       if (promote_var (v)
2106                           && DECL_INITIAL (v->decl)
2107                           && const_value_known_p (v->decl)
2108                           && !pointer_set_insert (inserted, vnode))
2109                         VEC_safe_push (varpool_node_ptr, heap,
2110                                        promoted_initializers, v);
2111                     }
2112                 }
2113             }
2114         }
2115     }
2116   pointer_set_destroy (inserted);
2117 }
2118
2119 static lto_file *current_lto_file;
2120
2121 /* Helper for qsort; compare partitions and return one with smaller size.
2122    We sort from greatest to smallest so parallel build doesn't stale on the
2123    longest compilation being executed too late.  */
2124
2125 static int
2126 cmp_partitions (const void *a, const void *b)
2127 {
2128   const struct ltrans_partition_def *pa
2129      = *(struct ltrans_partition_def *const *)a;
2130   const struct ltrans_partition_def *pb
2131      = *(struct ltrans_partition_def *const *)b;
2132   return pb->insns - pa->insns;
2133 }
2134
2135 /* Write all output files in WPA mode and the file with the list of
2136    LTRANS units.  */
2137
2138 static void
2139 lto_wpa_write_files (void)
2140 {
2141   unsigned i, n_sets;
2142   lto_file *file;
2143   cgraph_node_set set;
2144   varpool_node_set vset;
2145   ltrans_partition part;
2146   FILE *ltrans_output_list_stream;
2147   char *temp_filename;
2148   size_t blen;
2149
2150   /* Open the LTRANS output list.  */
2151   if (!ltrans_output_list)
2152     fatal_error ("no LTRANS output list filename provided");
2153   ltrans_output_list_stream = fopen (ltrans_output_list, "w");
2154   if (ltrans_output_list_stream == NULL)
2155     fatal_error ("opening LTRANS output list %s: %m", ltrans_output_list);
2156
2157   timevar_push (TV_WHOPR_WPA);
2158
2159   FOR_EACH_VEC_ELT (ltrans_partition, ltrans_partitions, i, part)
2160     lto_stats.num_output_cgraph_nodes += VEC_length (cgraph_node_ptr,
2161                                                      part->cgraph_set->nodes);
2162
2163   /* Find out statics that need to be promoted
2164      to globals with hidden visibility because they are accessed from multiple
2165      partitions.  */
2166   lto_promote_cross_file_statics ();
2167
2168   timevar_pop (TV_WHOPR_WPA);
2169
2170   timevar_push (TV_WHOPR_WPA_IO);
2171
2172   /* Generate a prefix for the LTRANS unit files.  */
2173   blen = strlen (ltrans_output_list);
2174   temp_filename = (char *) xmalloc (blen + sizeof ("2147483648.o"));
2175   strcpy (temp_filename, ltrans_output_list);
2176   if (blen > sizeof (".out")
2177       && strcmp (temp_filename + blen - sizeof (".out") + 1,
2178                  ".out") == 0)
2179     temp_filename[blen - sizeof (".out") + 1] = '\0';
2180   blen = strlen (temp_filename);
2181
2182   n_sets = VEC_length (ltrans_partition, ltrans_partitions);
2183   VEC_qsort (ltrans_partition, ltrans_partitions, cmp_partitions);
2184   for (i = 0; i < n_sets; i++)
2185     {
2186       size_t len;
2187       ltrans_partition part = VEC_index (ltrans_partition, ltrans_partitions, i);
2188
2189       set = part->cgraph_set;
2190       vset = part->varpool_set;
2191
2192       /* Write all the nodes in SET.  */
2193       sprintf (temp_filename + blen, "%u.o", i);
2194       file = lto_obj_file_open (temp_filename, true);
2195       if (!file)
2196         fatal_error ("lto_obj_file_open() failed");
2197
2198       if (!quiet_flag)
2199         fprintf (stderr, " %s (%s %i insns)", temp_filename, part->name, part->insns);
2200       if (cgraph_dump_file)
2201         {
2202           fprintf (cgraph_dump_file, "Writing partition %s to file %s, %i insns\n",
2203                    part->name, temp_filename, part->insns);
2204           fprintf (cgraph_dump_file, "cgraph nodes:");
2205           dump_cgraph_node_set (cgraph_dump_file, set);
2206           fprintf (cgraph_dump_file, "varpool nodes:");
2207           dump_varpool_node_set (cgraph_dump_file, vset);
2208         }
2209       gcc_checking_assert (cgraph_node_set_nonempty_p (set)
2210                            || varpool_node_set_nonempty_p (vset) || !i);
2211
2212       lto_set_current_out_file (file);
2213
2214       ipa_write_optimization_summaries (set, vset);
2215
2216       lto_set_current_out_file (NULL);
2217       lto_obj_file_close (file);
2218
2219       len = strlen (temp_filename);
2220       if (fwrite (temp_filename, 1, len, ltrans_output_list_stream) < len
2221           || fwrite ("\n", 1, 1, ltrans_output_list_stream) < 1)
2222         fatal_error ("writing to LTRANS output list %s: %m",
2223                      ltrans_output_list);
2224     }
2225
2226   lto_stats.num_output_files += n_sets;
2227
2228   /* Close the LTRANS output list.  */
2229   if (fclose (ltrans_output_list_stream))
2230     fatal_error ("closing LTRANS output list %s: %m", ltrans_output_list);
2231
2232   free_ltrans_partitions();
2233
2234   timevar_pop (TV_WHOPR_WPA_IO);
2235 }
2236
2237
2238 /* If TT is a variable or function decl replace it with its
2239    prevailing variant.  */
2240 #define LTO_SET_PREVAIL(tt) \
2241   do {\
2242     if ((tt) && VAR_OR_FUNCTION_DECL_P (tt)) \
2243       tt = lto_symtab_prevailing_decl (tt); \
2244   } while (0)
2245
2246 /* Ensure that TT isn't a replacable var of function decl.  */
2247 #define LTO_NO_PREVAIL(tt) \
2248   gcc_assert (!(tt) || !VAR_OR_FUNCTION_DECL_P (tt))
2249
2250 /* Given a tree T replace all fields referring to variables or functions
2251    with their prevailing variant.  */
2252 static void
2253 lto_fixup_prevailing_decls (tree t)
2254 {
2255   enum tree_code code = TREE_CODE (t);
2256   LTO_NO_PREVAIL (TREE_TYPE (t));
2257   if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
2258     LTO_NO_PREVAIL (TREE_CHAIN (t));
2259   if (DECL_P (t))
2260     {
2261       LTO_NO_PREVAIL (DECL_NAME (t));
2262       LTO_SET_PREVAIL (DECL_CONTEXT (t));
2263       if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
2264         {
2265           LTO_SET_PREVAIL (DECL_SIZE (t));
2266           LTO_SET_PREVAIL (DECL_SIZE_UNIT (t));
2267           LTO_SET_PREVAIL (DECL_INITIAL (t));
2268           LTO_NO_PREVAIL (DECL_ATTRIBUTES (t));
2269           LTO_SET_PREVAIL (DECL_ABSTRACT_ORIGIN (t));
2270         }
2271       if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
2272         {
2273           LTO_NO_PREVAIL (t->decl_with_vis.assembler_name);
2274           LTO_NO_PREVAIL (DECL_SECTION_NAME (t));
2275         }
2276       if (CODE_CONTAINS_STRUCT (code, TS_DECL_NON_COMMON))
2277         {
2278           LTO_NO_PREVAIL (DECL_ARGUMENT_FLD (t));
2279           LTO_NO_PREVAIL (DECL_RESULT_FLD (t));
2280           LTO_NO_PREVAIL (DECL_VINDEX (t));
2281         }
2282       if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL))
2283         LTO_SET_PREVAIL (DECL_FUNCTION_PERSONALITY (t));
2284       if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL))
2285         {
2286           LTO_NO_PREVAIL (DECL_FIELD_OFFSET (t));
2287           LTO_NO_PREVAIL (DECL_BIT_FIELD_TYPE (t));
2288           LTO_NO_PREVAIL (DECL_QUALIFIER (t));
2289           LTO_NO_PREVAIL (DECL_FIELD_BIT_OFFSET (t));
2290           LTO_NO_PREVAIL (DECL_FCONTEXT (t));
2291         }
2292     }
2293   else if (TYPE_P (t))
2294     {
2295       LTO_NO_PREVAIL (TYPE_CACHED_VALUES (t));
2296       LTO_SET_PREVAIL (TYPE_SIZE (t));
2297       LTO_SET_PREVAIL (TYPE_SIZE_UNIT (t));
2298       LTO_NO_PREVAIL (TYPE_ATTRIBUTES (t));
2299       LTO_NO_PREVAIL (TYPE_NAME (t));
2300
2301       LTO_SET_PREVAIL (TYPE_MINVAL (t));
2302       LTO_SET_PREVAIL (TYPE_MAXVAL (t));
2303       LTO_SET_PREVAIL (t->type_non_common.binfo);
2304
2305       LTO_SET_PREVAIL (TYPE_CONTEXT (t));
2306
2307       LTO_NO_PREVAIL (TYPE_CANONICAL (t));
2308       LTO_NO_PREVAIL (TYPE_MAIN_VARIANT (t));
2309       LTO_NO_PREVAIL (TYPE_NEXT_VARIANT (t));
2310     }
2311   else if (EXPR_P (t))
2312     {
2313       int i;
2314       LTO_NO_PREVAIL (t->exp.block);
2315       for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i)
2316         LTO_SET_PREVAIL (TREE_OPERAND (t, i));
2317     }
2318   else
2319     {
2320       switch (code)
2321         {
2322         case TREE_LIST:
2323           LTO_SET_PREVAIL (TREE_VALUE (t));
2324           LTO_SET_PREVAIL (TREE_PURPOSE (t));
2325           break;
2326         default:
2327           gcc_unreachable ();
2328         }
2329     }
2330 }
2331 #undef LTO_SET_PREVAIL
2332 #undef LTO_NO_PREVAIL
2333
2334 /* Helper function of lto_fixup_decls. Walks the var and fn streams in STATE,
2335    replaces var and function decls with the corresponding prevailing def.  */
2336
2337 static void
2338 lto_fixup_state (struct lto_in_decl_state *state)
2339 {
2340   unsigned i, si;
2341   struct lto_tree_ref_table *table;
2342
2343   /* Although we only want to replace FUNCTION_DECLs and VAR_DECLs,
2344      we still need to walk from all DECLs to find the reachable
2345      FUNCTION_DECLs and VAR_DECLs.  */
2346   for (si = 0; si < LTO_N_DECL_STREAMS; si++)
2347     {
2348       table = &state->streams[si];
2349       for (i = 0; i < table->size; i++)
2350         {
2351           tree *tp = table->trees + i;
2352           if (VAR_OR_FUNCTION_DECL_P (*tp))
2353             *tp = lto_symtab_prevailing_decl (*tp);
2354         }
2355     }
2356 }
2357
2358 /* A callback of htab_traverse. Just extracts a state from SLOT
2359    and calls lto_fixup_state. */
2360
2361 static int
2362 lto_fixup_state_aux (void **slot, void *aux ATTRIBUTE_UNUSED)
2363 {
2364   struct lto_in_decl_state *state = (struct lto_in_decl_state *) *slot;
2365   lto_fixup_state (state);
2366   return 1;
2367 }
2368
2369 /* Fix the decls from all FILES. Replaces each decl with the corresponding
2370    prevailing one.  */
2371
2372 static void
2373 lto_fixup_decls (struct lto_file_decl_data **files)
2374 {
2375   unsigned int i;
2376   htab_iterator hi;
2377   tree t;
2378
2379   FOR_EACH_HTAB_ELEMENT (tree_with_vars, t, tree, hi)
2380     lto_fixup_prevailing_decls (t);
2381
2382   for (i = 0; files[i]; i++)
2383     {
2384       struct lto_file_decl_data *file = files[i];
2385       struct lto_in_decl_state *state = file->global_decl_state;
2386       lto_fixup_state (state);
2387
2388       htab_traverse (file->function_decl_states, lto_fixup_state_aux, NULL);
2389     }
2390 }
2391
2392 /* Read the options saved from each file in the command line.  Called
2393    from lang_hooks.post_options which is called by process_options
2394    right before all the options are used to initialize the compiler.
2395    This assumes that decode_options has already run, so the
2396    num_in_fnames and in_fnames are properly set.
2397
2398    Note that this assumes that all the files had been compiled with
2399    the same options, which is not a good assumption.  In general,
2400    options ought to be read from all the files in the set and merged.
2401    However, it is still unclear what the merge rules should be.  */
2402
2403 void
2404 lto_read_all_file_options (void)
2405 {
2406   size_t i;
2407
2408   /* Clear any file options currently saved.  */
2409   lto_clear_file_options ();
2410
2411   /* Set the hooks to read ELF sections.  */
2412   lto_set_in_hooks (NULL, get_section_data, free_section_data);
2413   if (!quiet_flag)
2414     fprintf (stderr, "Reading command line options:");
2415
2416   for (i = 0; i < num_in_fnames; i++)
2417     {
2418       struct lto_file_decl_data *file_data;
2419       lto_file *file = lto_obj_file_open (in_fnames[i], false);
2420       if (!file)
2421         break;
2422       if (!quiet_flag)
2423         {
2424           fprintf (stderr, " %s", in_fnames[i]);
2425           fflush (stderr);
2426         }
2427
2428       file_data = XCNEW (struct lto_file_decl_data);
2429       file_data->file_name = file->filename;
2430       file_data->section_hash_table = lto_obj_build_section_table (file);
2431
2432       lto_read_file_options (file_data);
2433
2434       lto_obj_file_close (file);
2435       htab_delete (file_data->section_hash_table);
2436       free (file_data);
2437     }
2438
2439   if (!quiet_flag)
2440     fprintf (stderr, "\n");
2441
2442   /* Apply globally the options read from all the files.  */
2443   lto_reissue_options ();
2444 }
2445
2446 static GTY((length ("lto_stats.num_input_files + 1"))) struct lto_file_decl_data **all_file_decl_data;
2447
2448 /* Turn file datas for sub files into a single array, so that they look
2449    like separate files for further passes. */
2450
2451 static void
2452 lto_flatten_files (struct lto_file_decl_data **orig, int count, int last_file_ix)
2453 {
2454   struct lto_file_decl_data *n, *next;
2455   int i, k;
2456
2457   lto_stats.num_input_files = count;
2458   all_file_decl_data
2459     = ggc_alloc_cleared_vec_lto_file_decl_data_ptr (count + 1);
2460   /* Set the hooks so that all of the ipa passes can read in their data.  */
2461   lto_set_in_hooks (all_file_decl_data, get_section_data, free_section_data);
2462   for (i = 0, k = 0; i < last_file_ix; i++) 
2463     {
2464       for (n = orig[i]; n != NULL; n = next)
2465         {
2466           all_file_decl_data[k++] = n;
2467           next = n->next;
2468           n->next = NULL;
2469         }
2470     }
2471   all_file_decl_data[k] = NULL;
2472   gcc_assert (k == count);
2473 }
2474
2475 /* Input file data before flattening (i.e. splitting them to subfiles to support
2476    incremental linking.  */
2477 static int real_file_count;
2478 static GTY((length ("real_file_count + 1"))) struct lto_file_decl_data **real_file_decl_data;
2479
2480 /* Read all the symbols from the input files FNAMES.  NFILES is the
2481    number of files requested in the command line.  Instantiate a
2482    global call graph by aggregating all the sub-graphs found in each
2483    file.  */
2484
2485 static void
2486 read_cgraph_and_symbols (unsigned nfiles, const char **fnames)
2487 {
2488   unsigned int i, last_file_ix;
2489   FILE *resolution;
2490   struct cgraph_node *node;
2491   int count = 0;
2492   struct lto_file_decl_data **decl_data;
2493
2494   init_cgraph ();
2495
2496   timevar_push (TV_IPA_LTO_DECL_IN);
2497
2498   real_file_decl_data
2499     = decl_data = ggc_alloc_cleared_vec_lto_file_decl_data_ptr (nfiles + 1);
2500   real_file_count = nfiles;
2501
2502   /* Read the resolution file.  */
2503   resolution = NULL;
2504   if (resolution_file_name)
2505     {
2506       int t;
2507       unsigned num_objects;
2508
2509       resolution = fopen (resolution_file_name, "r");
2510       if (resolution == NULL)
2511         fatal_error ("could not open symbol resolution file: %m");
2512
2513       t = fscanf (resolution, "%u", &num_objects);
2514       gcc_assert (t == 1);
2515
2516       /* True, since the plugin splits the archives.  */
2517       gcc_assert (num_objects == nfiles);
2518     }
2519
2520   tree_with_vars = htab_create_ggc (101, htab_hash_pointer, htab_eq_pointer,
2521                                     NULL);
2522
2523   if (!quiet_flag)
2524     fprintf (stderr, "Reading object files:");
2525
2526   /* Read all of the object files specified on the command line.  */
2527   for (i = 0, last_file_ix = 0; i < nfiles; ++i)
2528     {
2529       struct lto_file_decl_data *file_data = NULL;
2530       if (!quiet_flag)
2531         {
2532           fprintf (stderr, " %s", fnames[i]);
2533           fflush (stderr);
2534         }
2535
2536       current_lto_file = lto_obj_file_open (fnames[i], false);
2537       if (!current_lto_file)
2538         break;
2539
2540       file_data = lto_file_read (current_lto_file, resolution, &count);
2541       if (!file_data)
2542         {
2543           lto_obj_file_close (current_lto_file);
2544           current_lto_file = NULL;
2545           break;
2546         }
2547
2548       decl_data[last_file_ix++] = file_data;
2549
2550       lto_obj_file_close (current_lto_file);
2551       current_lto_file = NULL;
2552       ggc_collect ();
2553     }
2554
2555   lto_flatten_files (decl_data, count, last_file_ix);
2556   lto_stats.num_input_files = count;
2557   ggc_free(decl_data);
2558   real_file_decl_data = NULL;
2559
2560   if (resolution_file_name)
2561     fclose (resolution);
2562
2563   /* Set the hooks so that all of the ipa passes can read in their data.  */
2564   lto_set_in_hooks (all_file_decl_data, get_section_data, free_section_data);
2565
2566   timevar_pop (TV_IPA_LTO_DECL_IN);
2567
2568   if (!quiet_flag)
2569     fprintf (stderr, "\nReading the callgraph\n");
2570
2571   timevar_push (TV_IPA_LTO_CGRAPH_IO);
2572   /* Read the callgraph.  */
2573   input_cgraph ();
2574   timevar_pop (TV_IPA_LTO_CGRAPH_IO);
2575
2576   if (!quiet_flag)
2577     fprintf (stderr, "Merging declarations\n");
2578
2579   timevar_push (TV_IPA_LTO_DECL_MERGE);
2580   /* Merge global decls.  */
2581   lto_symtab_merge_decls ();
2582
2583   /* If there were errors during symbol merging bail out, we have no
2584      good way to recover here.  */
2585   if (seen_error ())
2586     fatal_error ("errors during merging of translation units");
2587
2588   /* Fixup all decls and types and free the type hash tables.  */
2589   lto_fixup_decls (all_file_decl_data);
2590   htab_delete (tree_with_vars);
2591   tree_with_vars = NULL;
2592   free_gimple_type_tables ();
2593   ggc_collect ();
2594
2595   timevar_pop (TV_IPA_LTO_DECL_MERGE);
2596   /* Each pass will set the appropriate timer.  */
2597
2598   if (!quiet_flag)
2599     fprintf (stderr, "Reading summaries\n");
2600
2601   /* Read the IPA summary data.  */
2602   if (flag_ltrans)
2603     ipa_read_optimization_summaries ();
2604   else
2605     ipa_read_summaries ();
2606
2607   /* Finally merge the cgraph according to the decl merging decisions.  */
2608   timevar_push (TV_IPA_LTO_CGRAPH_MERGE);
2609   if (cgraph_dump_file)
2610     {
2611       fprintf (cgraph_dump_file, "Before merging:\n");
2612       dump_cgraph (cgraph_dump_file);
2613       dump_varpool (cgraph_dump_file);
2614     }
2615   lto_symtab_merge_cgraph_nodes ();
2616   ggc_collect ();
2617
2618   if (flag_ltrans)
2619     for (node = cgraph_nodes; node; node = node->next)
2620       {
2621         /* FIXME: ipa_transforms_to_apply holds list of passes that have optimization
2622            summaries computed and needs to apply changes.  At the moment WHOPR only
2623            supports inlining, so we can push it here by hand.  In future we need to stream
2624            this field into ltrans compilation.  */
2625         if (node->analyzed)
2626           VEC_safe_push (ipa_opt_pass, heap,
2627                          node->ipa_transforms_to_apply,
2628                          (ipa_opt_pass)&pass_ipa_inline);
2629       }
2630   lto_symtab_free ();
2631
2632   timevar_pop (TV_IPA_LTO_CGRAPH_MERGE);
2633
2634   timevar_push (TV_IPA_LTO_DECL_INIT_IO);
2635
2636   /* FIXME lto. This loop needs to be changed to use the pass manager to
2637      call the ipa passes directly.  */
2638   if (!seen_error ())
2639     for (i = 0; i < last_file_ix; i++)
2640       {
2641         struct lto_file_decl_data *file_data = all_file_decl_data [i];
2642         lto_materialize_constructors_and_inits (file_data);
2643       }
2644
2645   /* Indicate that the cgraph is built and ready.  */
2646   cgraph_function_flags_ready = true;
2647
2648   timevar_pop (TV_IPA_LTO_DECL_INIT_IO);
2649   ggc_free (all_file_decl_data);
2650   all_file_decl_data = NULL;
2651 }
2652
2653
2654 /* Materialize all the bodies for all the nodes in the callgraph.  */
2655
2656 static void
2657 materialize_cgraph (void)
2658 {
2659   tree decl;
2660   struct cgraph_node *node; 
2661   unsigned i;
2662   timevar_id_t lto_timer;
2663
2664   if (!quiet_flag)
2665     fprintf (stderr,
2666              flag_wpa ? "Materializing decls:" : "Reading function bodies:");
2667
2668
2669   /* Now that we have input the cgraph, we need to clear all of the aux
2670      nodes and read the functions if we are not running in WPA mode.  */
2671   timevar_push (TV_IPA_LTO_GIMPLE_IN);
2672
2673   for (node = cgraph_nodes; node; node = node->next)
2674     {
2675       if (node->local.lto_file_data)
2676         {
2677           lto_materialize_function (node);
2678           lto_stats.num_input_cgraph_nodes++;
2679         }
2680     }
2681
2682   timevar_pop (TV_IPA_LTO_GIMPLE_IN);
2683
2684   /* Start the appropriate timer depending on the mode that we are
2685      operating in.  */
2686   lto_timer = (flag_wpa) ? TV_WHOPR_WPA
2687               : (flag_ltrans) ? TV_WHOPR_LTRANS
2688               : TV_LTO;
2689   timevar_push (lto_timer);
2690
2691   current_function_decl = NULL;
2692   set_cfun (NULL);
2693
2694   /* Inform the middle end about the global variables we have seen.  */
2695   FOR_EACH_VEC_ELT (tree, lto_global_var_decls, i, decl)
2696     rest_of_decl_compilation (decl, 1, 0);
2697
2698   if (!quiet_flag)
2699     fprintf (stderr, "\n");
2700
2701   timevar_pop (lto_timer);
2702 }
2703
2704
2705 /* Perform whole program analysis (WPA) on the callgraph and write out the
2706    optimization plan.  */
2707
2708 static void
2709 do_whole_program_analysis (void)
2710 {
2711   /* Note that since we are in WPA mode, materialize_cgraph will not
2712      actually read in all the function bodies.  It only materializes
2713      the decls and cgraph nodes so that analysis can be performed.  */
2714   materialize_cgraph ();
2715
2716   /* Reading in the cgraph uses different timers, start timing WPA now.  */
2717   timevar_push (TV_WHOPR_WPA);
2718
2719   if (pre_ipa_mem_report)
2720     {
2721       fprintf (stderr, "Memory consumption before IPA\n");
2722       dump_memory_report (false);
2723     }
2724
2725   cgraph_function_flags_ready = true;
2726
2727   if (cgraph_dump_file)
2728     {
2729       dump_cgraph (cgraph_dump_file);
2730       dump_varpool (cgraph_dump_file);
2731     }
2732   bitmap_obstack_initialize (NULL);
2733   cgraph_state = CGRAPH_STATE_IPA_SSA;
2734
2735   execute_ipa_pass_list (all_regular_ipa_passes);
2736
2737   if (cgraph_dump_file)
2738     {
2739       fprintf (cgraph_dump_file, "Optimized ");
2740       dump_cgraph (cgraph_dump_file);
2741       dump_varpool (cgraph_dump_file);
2742     }
2743   verify_cgraph ();
2744   bitmap_obstack_release (NULL);
2745
2746   /* We are about to launch the final LTRANS phase, stop the WPA timer.  */
2747   timevar_pop (TV_WHOPR_WPA);
2748
2749   if (flag_lto_partition_1to1)
2750     lto_1_to_1_map ();
2751   else
2752     lto_balanced_map ();
2753
2754   if (!quiet_flag)
2755     {
2756       fprintf (stderr, "\nStreaming out");
2757       fflush (stderr);
2758     }
2759   lto_wpa_write_files ();
2760   ggc_collect ();
2761   if (!quiet_flag)
2762     fprintf (stderr, "\n");
2763
2764   if (post_ipa_mem_report)
2765     {
2766       fprintf (stderr, "Memory consumption after IPA\n");
2767       dump_memory_report (false);
2768     }
2769
2770   /* Show the LTO report before launching LTRANS.  */
2771   if (flag_lto_report)
2772     print_lto_report ();
2773 }
2774
2775
2776 static GTY(()) tree lto_eh_personality_decl;
2777
2778 /* Return the LTO personality function decl.  */
2779
2780 tree
2781 lto_eh_personality (void)
2782 {
2783   if (!lto_eh_personality_decl)
2784     {
2785       /* Use the first personality DECL for our personality if we don't
2786          support multiple ones.  This ensures that we don't artificially
2787          create the need for them in a single-language program.  */
2788       if (first_personality_decl && !dwarf2out_do_cfi_asm ())
2789         lto_eh_personality_decl = first_personality_decl;
2790       else
2791         lto_eh_personality_decl = lhd_gcc_personality ();
2792     }
2793
2794   return lto_eh_personality_decl;
2795 }
2796
2797 /* Set the process name based on the LTO mode. */
2798
2799 static void 
2800 lto_process_name (void)
2801 {
2802   if (flag_lto)
2803     setproctitle ("lto1-lto");
2804   if (flag_wpa)
2805     setproctitle ("lto1-wpa");
2806   if (flag_ltrans)
2807     setproctitle ("lto1-ltrans");
2808 }
2809
2810
2811 /* Initialize the LTO front end.  */
2812
2813 static void
2814 lto_init (void)
2815 {
2816   lto_process_name ();
2817   lto_streamer_hooks_init ();
2818   lto_reader_init ();
2819   memset (&lto_stats, 0, sizeof (lto_stats));
2820   bitmap_obstack_initialize (NULL);
2821   gimple_register_cfg_hooks ();
2822 }
2823
2824
2825 /* Main entry point for the GIMPLE front end.  This front end has
2826    three main personalities:
2827
2828    - LTO (-flto).  All the object files on the command line are
2829      loaded in memory and processed as a single translation unit.
2830      This is the traditional link-time optimization behavior.
2831
2832    - WPA (-fwpa).  Only the callgraph and summary information for
2833      files in the command file are loaded.  A single callgraph
2834      (without function bodies) is instantiated for the whole set of
2835      files.  IPA passes are only allowed to analyze the call graph
2836      and make transformation decisions.  The callgraph is
2837      partitioned, each partition is written to a new object file
2838      together with the transformation decisions.
2839
2840    - LTRANS (-fltrans).  Similar to -flto but it prevents the IPA
2841      summary files from running again.  Since WPA computed summary
2842      information and decided what transformations to apply, LTRANS
2843      simply applies them.  */
2844
2845 void
2846 lto_main (void)
2847 {
2848   /* Initialize the LTO front end.  */
2849   lto_init ();
2850
2851   /* Read all the symbols and call graph from all the files in the
2852      command line.  */
2853   read_cgraph_and_symbols (num_in_fnames, in_fnames);
2854
2855   if (!seen_error ())
2856     {
2857       /* If WPA is enabled analyze the whole call graph and create an
2858          optimization plan.  Otherwise, read in all the function
2859          bodies and continue with optimization.  */
2860       if (flag_wpa)
2861         do_whole_program_analysis ();
2862       else
2863         {
2864           materialize_cgraph ();
2865
2866           /* Let the middle end know that we have read and merged all of
2867              the input files.  */ 
2868           cgraph_optimize ();
2869
2870           /* FIXME lto, if the processes spawned by WPA fail, we miss
2871              the chance to print WPA's report, so WPA will call
2872              print_lto_report before launching LTRANS.  If LTRANS was
2873              launched directly by the driver we would not need to do
2874              this.  */
2875           if (flag_lto_report)
2876             print_lto_report ();
2877         }
2878     }
2879 }
2880
2881 #include "gt-lto-lto.h"