OSDN Git Service

PR middle-end/42344
[pf3gnuchains/gcc-fork.git] / gcc / cgraphunit.c
1 /* Callgraph based interprocedural optimizations.
2    Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3    Free Software Foundation, Inc.
4    Contributed by Jan Hubicka
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3.  If not see
20 <http://www.gnu.org/licenses/>.  */
21
22 /* This module implements main driver of compilation process as well as
23    few basic interprocedural optimizers.
24
25    The main scope of this file is to act as an interface in between
26    tree based frontends and the backend (and middle end)
27
28    The front-end is supposed to use following functionality:
29
30     - cgraph_finalize_function
31
32       This function is called once front-end has parsed whole body of function
33       and it is certain that the function body nor the declaration will change.
34
35       (There is one exception needed for implementing GCC extern inline
36         function.)
37
38     - varpool_finalize_variable
39
40       This function has same behavior as the above but is used for static
41       variables.
42
43     - cgraph_finalize_compilation_unit
44
45       This function is called once (source level) compilation unit is finalized
46       and it will no longer change.
47
48       In the the call-graph construction and local function
49       analysis takes place here.  Bodies of unreachable functions are released
50       to conserve memory usage.
51
52       The function can be called multiple times when multiple source level
53       compilation units are combined (such as in C frontend)
54
55     - cgraph_optimize
56
57       In this unit-at-a-time compilation the intra procedural analysis takes
58       place here.  In particular the static functions whose address is never
59       taken are marked as local.  Backend can then use this information to
60       modify calling conventions, do better inlining or similar optimizations.
61
62     - cgraph_mark_needed_node
63     - varpool_mark_needed_node
64
65       When function or variable is referenced by some hidden way the call-graph
66       data structure must be updated accordingly by this function.
67       There should be little need to call this function and all the references
68       should be made explicit to cgraph code.  At present these functions are
69       used by C++ frontend to explicitly mark the keyed methods.
70
71     - analyze_expr callback
72
73       This function is responsible for lowering tree nodes not understood by
74       generic code into understandable ones or alternatively marking
75       callgraph and varpool nodes referenced by the as needed.
76
77       ??? On the tree-ssa genericizing should take place here and we will avoid
78       need for these hooks (replacing them by genericizing hook)
79
80         Analyzing of all functions is deferred
81         to cgraph_finalize_compilation_unit and expansion into cgraph_optimize.
82
83         In cgraph_finalize_compilation_unit the reachable functions are
84         analyzed.  During analysis the call-graph edges from reachable
85         functions are constructed and their destinations are marked as
86         reachable.  References to functions and variables are discovered too
87         and variables found to be needed output to the assembly file.  Via
88         mark_referenced call in assemble_variable functions referenced by
89         static variables are noticed too.
90
91         The intra-procedural information is produced and its existence
92         indicated by global_info_ready.  Once this flag is set it is impossible
93         to change function from !reachable to reachable and thus
94         assemble_variable no longer call mark_referenced.
95
96         Finally the call-graph is topologically sorted and all reachable functions
97         that has not been completely inlined or are not external are output.
98
99         ??? It is possible that reference to function or variable is optimized
100         out.  We can not deal with this nicely because topological order is not
101         suitable for it.  For tree-ssa we may consider another pass doing
102         optimization and re-discovering reachable functions.
103
104         ??? Reorganize code so variables are output very last and only if they
105         really has been referenced by produced code, so we catch more cases
106         where reference has been optimized out.  */
107
108
109 #include "config.h"
110 #include "system.h"
111 #include "coretypes.h"
112 #include "tm.h"
113 #include "tree.h"
114 #include "rtl.h"
115 #include "tree-flow.h"
116 #include "tree-inline.h"
117 #include "langhooks.h"
118 #include "pointer-set.h"
119 #include "toplev.h"
120 #include "flags.h"
121 #include "ggc.h"
122 #include "debug.h"
123 #include "target.h"
124 #include "cgraph.h"
125 #include "diagnostic.h"
126 #include "timevar.h"
127 #include "params.h"
128 #include "fibheap.h"
129 #include "intl.h"
130 #include "function.h"
131 #include "ipa-prop.h"
132 #include "gimple.h"
133 #include "tree-iterator.h"
134 #include "tree-pass.h"
135 #include "tree-dump.h"
136 #include "output.h"
137 #include "coverage.h"
138 #include "plugin.h"
139
140 static void cgraph_expand_all_functions (void);
141 static void cgraph_mark_functions_to_output (void);
142 static void cgraph_expand_function (struct cgraph_node *);
143 static void cgraph_output_pending_asms (void);
144 static void cgraph_analyze_function (struct cgraph_node *);
145
146 static FILE *cgraph_dump_file;
147
148 /* A vector of FUNCTION_DECLs declared as static constructors.  */
149 static GTY (()) VEC(tree, gc) *static_ctors;
150 /* A vector of FUNCTION_DECLs declared as static destructors.  */
151 static GTY (()) VEC(tree, gc) *static_dtors;
152
153 /* Used for vtable lookup in thunk adjusting.  */
154 static GTY (()) tree vtable_entry_type;
155
156 /* When target does not have ctors and dtors, we call all constructor
157    and destructor by special initialization/destruction function
158    recognized by collect2.
159
160    When we are going to build this function, collect all constructors and
161    destructors and turn them into normal functions.  */
162
163 static void
164 record_cdtor_fn (tree fndecl)
165 {
166   struct cgraph_node *node;
167   if (targetm.have_ctors_dtors
168       || (!DECL_STATIC_CONSTRUCTOR (fndecl)
169           && !DECL_STATIC_DESTRUCTOR (fndecl)))
170     return;
171
172   if (DECL_STATIC_CONSTRUCTOR (fndecl))
173     {
174       VEC_safe_push (tree, gc, static_ctors, fndecl);
175       DECL_STATIC_CONSTRUCTOR (fndecl) = 0;
176     }
177   if (DECL_STATIC_DESTRUCTOR (fndecl))
178     {
179       VEC_safe_push (tree, gc, static_dtors, fndecl);
180       DECL_STATIC_DESTRUCTOR (fndecl) = 0;
181     }
182   node = cgraph_node (fndecl);
183   node->local.disregard_inline_limits = 1;
184   cgraph_mark_reachable_node (node);
185 }
186
187 /* Define global constructors/destructor functions for the CDTORS, of
188    which they are LEN.  The CDTORS are sorted by initialization
189    priority.  If CTOR_P is true, these are constructors; otherwise,
190    they are destructors.  */
191
192 static void
193 build_cdtor (bool ctor_p, tree *cdtors, size_t len)
194 {
195   size_t i;
196
197   i = 0;
198   while (i < len)
199     {
200       tree body;
201       tree fn;
202       priority_type priority;
203
204       priority = 0;
205       body = NULL_TREE;
206       /* Find the next batch of constructors/destructors with the same
207          initialization priority.  */
208       do
209         {
210           priority_type p;
211           fn = cdtors[i];
212           p = ctor_p ? DECL_INIT_PRIORITY (fn) : DECL_FINI_PRIORITY (fn);
213           if (!body)
214             priority = p;
215           else if (p != priority)
216             break;
217           append_to_statement_list (build_function_call_expr (UNKNOWN_LOCATION,
218                                                               fn, 0),
219                                     &body);
220           ++i;
221         }
222       while (i < len);
223       gcc_assert (body != NULL_TREE);
224       /* Generate a function to call all the function of like
225          priority.  */
226       cgraph_build_static_cdtor (ctor_p ? 'I' : 'D', body, priority);
227     }
228 }
229
230 /* Comparison function for qsort.  P1 and P2 are actually of type
231    "tree *" and point to static constructors.  DECL_INIT_PRIORITY is
232    used to determine the sort order.  */
233
234 static int
235 compare_ctor (const void *p1, const void *p2)
236 {
237   tree f1;
238   tree f2;
239   int priority1;
240   int priority2;
241
242   f1 = *(const tree *)p1;
243   f2 = *(const tree *)p2;
244   priority1 = DECL_INIT_PRIORITY (f1);
245   priority2 = DECL_INIT_PRIORITY (f2);
246
247   if (priority1 < priority2)
248     return -1;
249   else if (priority1 > priority2)
250     return 1;
251   else
252     /* Ensure a stable sort.  */
253     return (const tree *)p1 - (const tree *)p2;
254 }
255
256 /* Comparison function for qsort.  P1 and P2 are actually of type
257    "tree *" and point to static destructors.  DECL_FINI_PRIORITY is
258    used to determine the sort order.  */
259
260 static int
261 compare_dtor (const void *p1, const void *p2)
262 {
263   tree f1;
264   tree f2;
265   int priority1;
266   int priority2;
267
268   f1 = *(const tree *)p1;
269   f2 = *(const tree *)p2;
270   priority1 = DECL_FINI_PRIORITY (f1);
271   priority2 = DECL_FINI_PRIORITY (f2);
272
273   if (priority1 < priority2)
274     return -1;
275   else if (priority1 > priority2)
276     return 1;
277   else
278     /* Ensure a stable sort.  */
279     return (const tree *)p1 - (const tree *)p2;
280 }
281
282 /* Generate functions to call static constructors and destructors
283    for targets that do not support .ctors/.dtors sections.  These
284    functions have magic names which are detected by collect2.  */
285
286 static void
287 cgraph_build_cdtor_fns (void)
288 {
289   if (!VEC_empty (tree, static_ctors))
290     {
291       gcc_assert (!targetm.have_ctors_dtors);
292       qsort (VEC_address (tree, static_ctors),
293              VEC_length (tree, static_ctors),
294              sizeof (tree),
295              compare_ctor);
296       build_cdtor (/*ctor_p=*/true,
297                    VEC_address (tree, static_ctors),
298                    VEC_length (tree, static_ctors));
299       VEC_truncate (tree, static_ctors, 0);
300     }
301
302   if (!VEC_empty (tree, static_dtors))
303     {
304       gcc_assert (!targetm.have_ctors_dtors);
305       qsort (VEC_address (tree, static_dtors),
306              VEC_length (tree, static_dtors),
307              sizeof (tree),
308              compare_dtor);
309       build_cdtor (/*ctor_p=*/false,
310                    VEC_address (tree, static_dtors),
311                    VEC_length (tree, static_dtors));
312       VEC_truncate (tree, static_dtors, 0);
313     }
314 }
315
316 /* Determine if function DECL is needed.  That is, visible to something
317    either outside this translation unit, something magic in the system
318    configury.  */
319
320 bool
321 cgraph_decide_is_function_needed (struct cgraph_node *node, tree decl)
322 {
323   /* If the user told us it is used, then it must be so.  */
324   if (node->local.externally_visible)
325     return true;
326
327   /* ??? If the assembler name is set by hand, it is possible to assemble
328      the name later after finalizing the function and the fact is noticed
329      in assemble_name then.  This is arguably a bug.  */
330   if (DECL_ASSEMBLER_NAME_SET_P (decl)
331       && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
332     return true;
333
334   /* With -fkeep-inline-functions we are keeping all inline functions except
335      for extern inline ones.  */
336   if (flag_keep_inline_functions
337       && DECL_DECLARED_INLINE_P (decl)
338       && !DECL_EXTERNAL (decl)
339       && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (decl)))
340      return true;
341
342   /* If we decided it was needed before, but at the time we didn't have
343      the body of the function available, then it's still needed.  We have
344      to go back and re-check its dependencies now.  */
345   if (node->needed)
346     return true;
347
348   /* Externally visible functions must be output.  The exception is
349      COMDAT functions that must be output only when they are needed.
350
351      When not optimizing, also output the static functions. (see
352      PR24561), but don't do so for always_inline functions, functions
353      declared inline and nested functions.  These was optimized out
354      in the original implementation and it is unclear whether we want
355      to change the behavior here.  */
356   if (((TREE_PUBLIC (decl)
357         || (!optimize && !node->local.disregard_inline_limits
358             && !DECL_DECLARED_INLINE_P (decl)
359             && !node->origin))
360        && !flag_whole_program
361        && !flag_lto
362        && !flag_whopr)
363       && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl))
364     return true;
365
366   /* Constructors and destructors are reachable from the runtime by
367      some mechanism.  */
368   if (DECL_STATIC_CONSTRUCTOR (decl) || DECL_STATIC_DESTRUCTOR (decl))
369     return true;
370
371   return false;
372 }
373
374 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
375    functions into callgraph in a way so they look like ordinary reachable
376    functions inserted into callgraph already at construction time.  */
377
378 bool
379 cgraph_process_new_functions (void)
380 {
381   bool output = false;
382   tree fndecl;
383   struct cgraph_node *node;
384
385   /*  Note that this queue may grow as its being processed, as the new
386       functions may generate new ones.  */
387   while (cgraph_new_nodes)
388     {
389       node = cgraph_new_nodes;
390       fndecl = node->decl;
391       cgraph_new_nodes = cgraph_new_nodes->next_needed;
392       switch (cgraph_state)
393         {
394         case CGRAPH_STATE_CONSTRUCTION:
395           /* At construction time we just need to finalize function and move
396              it into reachable functions list.  */
397
398           node->next_needed = NULL;
399           cgraph_finalize_function (fndecl, false);
400           cgraph_mark_reachable_node (node);
401           output = true;
402           break;
403
404         case CGRAPH_STATE_IPA:
405         case CGRAPH_STATE_IPA_SSA:
406           /* When IPA optimization already started, do all essential
407              transformations that has been already performed on the whole
408              cgraph but not on this function.  */
409
410           gimple_register_cfg_hooks ();
411           if (!node->analyzed)
412             cgraph_analyze_function (node);
413           push_cfun (DECL_STRUCT_FUNCTION (fndecl));
414           current_function_decl = fndecl;
415           compute_inline_parameters (node);
416           if ((cgraph_state == CGRAPH_STATE_IPA_SSA
417               && !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl)))
418               /* When not optimizing, be sure we run early local passes anyway
419                  to expand OMP.  */
420               || !optimize)
421             execute_pass_list (pass_early_local_passes.pass.sub);
422           free_dominance_info (CDI_POST_DOMINATORS);
423           free_dominance_info (CDI_DOMINATORS);
424           pop_cfun ();
425           current_function_decl = NULL;
426           break;
427
428         case CGRAPH_STATE_EXPANSION:
429           /* Functions created during expansion shall be compiled
430              directly.  */
431           node->process = 0;
432           cgraph_expand_function (node);
433           break;
434
435         default:
436           gcc_unreachable ();
437           break;
438         }
439       cgraph_call_function_insertion_hooks (node);
440     }
441   return output;
442 }
443
444 /* As an GCC extension we allow redefinition of the function.  The
445    semantics when both copies of bodies differ is not well defined.
446    We replace the old body with new body so in unit at a time mode
447    we always use new body, while in normal mode we may end up with
448    old body inlined into some functions and new body expanded and
449    inlined in others.
450
451    ??? It may make more sense to use one body for inlining and other
452    body for expanding the function but this is difficult to do.  */
453
454 static void
455 cgraph_reset_node (struct cgraph_node *node)
456 {
457   /* If node->process is set, then we have already begun whole-unit analysis.
458      This is *not* testing for whether we've already emitted the function.
459      That case can be sort-of legitimately seen with real function redefinition
460      errors.  I would argue that the front end should never present us with
461      such a case, but don't enforce that for now.  */
462   gcc_assert (!node->process);
463
464   /* Reset our data structures so we can analyze the function again.  */
465   memset (&node->local, 0, sizeof (node->local));
466   memset (&node->global, 0, sizeof (node->global));
467   memset (&node->rtl, 0, sizeof (node->rtl));
468   node->analyzed = false;
469   node->local.redefined_extern_inline = true;
470   node->local.finalized = false;
471
472   cgraph_node_remove_callees (node);
473
474   /* We may need to re-queue the node for assembling in case
475      we already proceeded it and ignored as not needed or got
476      a re-declaration in IMA mode.  */
477   if (node->reachable)
478     {
479       struct cgraph_node *n;
480
481       for (n = cgraph_nodes_queue; n; n = n->next_needed)
482         if (n == node)
483           break;
484       if (!n)
485         node->reachable = 0;
486     }
487 }
488
489 static void
490 cgraph_lower_function (struct cgraph_node *node)
491 {
492   if (node->lowered)
493     return;
494
495   if (node->nested)
496     lower_nested_functions (node->decl);
497   gcc_assert (!node->nested);
498
499   tree_lowering_passes (node->decl);
500   node->lowered = true;
501 }
502
503 /* DECL has been parsed.  Take it, queue it, compile it at the whim of the
504    logic in effect.  If NESTED is true, then our caller cannot stand to have
505    the garbage collector run at the moment.  We would need to either create
506    a new GC context, or just not compile right now.  */
507
508 void
509 cgraph_finalize_function (tree decl, bool nested)
510 {
511   struct cgraph_node *node = cgraph_node (decl);
512
513   if (node->local.finalized)
514     cgraph_reset_node (node);
515
516   node->pid = cgraph_max_pid ++;
517   notice_global_symbol (decl);
518   node->local.finalized = true;
519   node->lowered = DECL_STRUCT_FUNCTION (decl)->cfg != NULL;
520   node->finalized_by_frontend = true;
521   record_cdtor_fn (node->decl);
522
523   if (cgraph_decide_is_function_needed (node, decl))
524     cgraph_mark_needed_node (node);
525
526   /* Since we reclaim unreachable nodes at the end of every language
527      level unit, we need to be conservative about possible entry points
528      there.  */
529   if ((TREE_PUBLIC (decl) && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl)))
530     cgraph_mark_reachable_node (node);
531
532   /* If we've not yet emitted decl, tell the debug info about it.  */
533   if (!TREE_ASM_WRITTEN (decl))
534     (*debug_hooks->deferred_inline_function) (decl);
535
536   /* Possibly warn about unused parameters.  */
537   if (warn_unused_parameter)
538     do_warn_unused_parameter (decl);
539
540   if (!nested)
541     ggc_collect ();
542 }
543
544 /* C99 extern inline keywords allow changing of declaration after function
545    has been finalized.  We need to re-decide if we want to mark the function as
546    needed then.   */
547
548 void
549 cgraph_mark_if_needed (tree decl)
550 {
551   struct cgraph_node *node = cgraph_node (decl);
552   if (node->local.finalized && cgraph_decide_is_function_needed (node, decl))
553     cgraph_mark_needed_node (node);
554 }
555
556 /* Return TRUE if NODE2 is equivalent to NODE or its clone.  */
557 static bool
558 clone_of_p (struct cgraph_node *node, struct cgraph_node *node2)
559 {
560   while (node != node2 && node2)
561     node2 = node2->clone_of;
562   return node2 != NULL;
563 }
564
565 /* Verify cgraph nodes of given cgraph node.  */
566 void
567 verify_cgraph_node (struct cgraph_node *node)
568 {
569   struct cgraph_edge *e;
570   struct function *this_cfun = DECL_STRUCT_FUNCTION (node->decl);
571   struct function *saved_cfun = cfun;
572   basic_block this_block;
573   gimple_stmt_iterator gsi;
574   bool error_found = false;
575
576   if (errorcount || sorrycount)
577     return;
578
579   timevar_push (TV_CGRAPH_VERIFY);
580   /* debug_generic_stmt needs correct cfun */
581   set_cfun (this_cfun);
582   for (e = node->callees; e; e = e->next_callee)
583     if (e->aux)
584       {
585         error ("aux field set for edge %s->%s",
586                identifier_to_locale (cgraph_node_name (e->caller)),
587                identifier_to_locale (cgraph_node_name (e->callee)));
588         error_found = true;
589       }
590   if (node->count < 0)
591     {
592       error ("Execution count is negative");
593       error_found = true;
594     }
595   if (node->global.inlined_to && node->local.externally_visible)
596     {
597       error ("Externally visible inline clone");
598       error_found = true;
599     }
600   if (node->global.inlined_to && node->address_taken)
601     {
602       error ("Inline clone with address taken");
603       error_found = true;
604     }
605   if (node->global.inlined_to && node->needed)
606     {
607       error ("Inline clone is needed");
608       error_found = true;
609     }
610   for (e = node->callers; e; e = e->next_caller)
611     {
612       if (e->count < 0)
613         {
614           error ("caller edge count is negative");
615           error_found = true;
616         }
617       if (e->frequency < 0)
618         {
619           error ("caller edge frequency is negative");
620           error_found = true;
621         }
622       if (e->frequency > CGRAPH_FREQ_MAX)
623         {
624           error ("caller edge frequency is too large");
625           error_found = true;
626         }
627       if (gimple_has_body_p (e->caller->decl)
628           && !e->caller->global.inlined_to
629           && (e->frequency
630               != compute_call_stmt_bb_frequency (e->caller->decl,
631                                                  gimple_bb (e->call_stmt))))
632         {
633           error ("caller edge frequency %i does not match BB freqency %i",
634                  e->frequency,
635                  compute_call_stmt_bb_frequency (e->caller->decl,
636                                                  gimple_bb (e->call_stmt)));
637           error_found = true;
638         }
639       if (!e->inline_failed)
640         {
641           if (node->global.inlined_to
642               != (e->caller->global.inlined_to
643                   ? e->caller->global.inlined_to : e->caller))
644             {
645               error ("inlined_to pointer is wrong");
646               error_found = true;
647             }
648           if (node->callers->next_caller)
649             {
650               error ("multiple inline callers");
651               error_found = true;
652             }
653         }
654       else
655         if (node->global.inlined_to)
656           {
657             error ("inlined_to pointer set for noninline callers");
658             error_found = true;
659           }
660     }
661   if (!node->callers && node->global.inlined_to)
662     {
663       error ("inlined_to pointer is set but no predecessors found");
664       error_found = true;
665     }
666   if (node->global.inlined_to == node)
667     {
668       error ("inlined_to pointer refers to itself");
669       error_found = true;
670     }
671
672   if (!cgraph_node (node->decl))
673     {
674       error ("node not found in cgraph_hash");
675       error_found = true;
676     }
677
678   if (node->clone_of)
679     {
680       struct cgraph_node *n;
681       for (n = node->clone_of->clones; n; n = n->next_sibling_clone)
682         if (n == node)
683           break;
684       if (!n)
685         {
686           error ("node has wrong clone_of");
687           error_found = true;
688         }
689     }
690   if (node->clones)
691     {
692       struct cgraph_node *n;
693       for (n = node->clones; n; n = n->next_sibling_clone)
694         if (n->clone_of != node)
695           break;
696       if (n)
697         {
698           error ("node has wrong clone list");
699           error_found = true;
700         }
701     }
702   if ((node->prev_sibling_clone || node->next_sibling_clone) && !node->clone_of)
703     {
704        error ("node is in clone list but it is not clone");
705        error_found = true;
706     }
707   if (!node->prev_sibling_clone && node->clone_of && node->clone_of->clones != node)
708     {
709       error ("node has wrong prev_clone pointer");
710       error_found = true;
711     }
712   if (node->prev_sibling_clone && node->prev_sibling_clone->next_sibling_clone != node)
713     {
714       error ("double linked list of clones corrupted");
715       error_found = true;
716     }
717
718   if (node->analyzed && gimple_has_body_p (node->decl)
719       && !TREE_ASM_WRITTEN (node->decl)
720       && (!DECL_EXTERNAL (node->decl) || node->global.inlined_to)
721       && !flag_wpa)
722     {
723       if (this_cfun->cfg)
724         {
725           /* The nodes we're interested in are never shared, so walk
726              the tree ignoring duplicates.  */
727           struct pointer_set_t *visited_nodes = pointer_set_create ();
728           /* Reach the trees by walking over the CFG, and note the
729              enclosing basic-blocks in the call edges.  */
730           FOR_EACH_BB_FN (this_block, this_cfun)
731             for (gsi = gsi_start_bb (this_block);
732                  !gsi_end_p (gsi);
733                  gsi_next (&gsi))
734               {
735                 gimple stmt = gsi_stmt (gsi);
736                 tree decl;
737                 if (is_gimple_call (stmt) && (decl = gimple_call_fndecl (stmt)))
738                   {
739                     struct cgraph_edge *e = cgraph_edge (node, stmt);
740                     if (e)
741                       {
742                         if (e->aux)
743                           {
744                             error ("shared call_stmt:");
745                             debug_gimple_stmt (stmt);
746                             error_found = true;
747                           }
748                         if (e->callee->same_body_alias)
749                           {
750                             error ("edge points to same body alias:");
751                             debug_tree (e->callee->decl);
752                             error_found = true;
753                           }
754                         else if (!clone_of_p (cgraph_node (decl), e->callee)
755                                  && !e->callee->global.inlined_to)
756                           {
757                             error ("edge points to wrong declaration:");
758                             debug_tree (e->callee->decl);
759                             fprintf (stderr," Instead of:");
760                             debug_tree (decl);
761                             error_found = true;
762                           }
763                         e->aux = (void *)1;
764                       }
765                     else
766                       {
767                         error ("missing callgraph edge for call stmt:");
768                         debug_gimple_stmt (stmt);
769                         error_found = true;
770                       }
771                   }
772               }
773           pointer_set_destroy (visited_nodes);
774         }
775       else
776         /* No CFG available?!  */
777         gcc_unreachable ();
778
779       for (e = node->callees; e; e = e->next_callee)
780         {
781           if (!e->aux && !e->indirect_call)
782             {
783               error ("edge %s->%s has no corresponding call_stmt",
784                      identifier_to_locale (cgraph_node_name (e->caller)),
785                      identifier_to_locale (cgraph_node_name (e->callee)));
786               debug_gimple_stmt (e->call_stmt);
787               error_found = true;
788             }
789           e->aux = 0;
790         }
791     }
792   if (error_found)
793     {
794       dump_cgraph_node (stderr, node);
795       internal_error ("verify_cgraph_node failed");
796     }
797   set_cfun (saved_cfun);
798   timevar_pop (TV_CGRAPH_VERIFY);
799 }
800
801 /* Verify whole cgraph structure.  */
802 void
803 verify_cgraph (void)
804 {
805   struct cgraph_node *node;
806
807   if (sorrycount || errorcount)
808     return;
809
810   for (node = cgraph_nodes; node; node = node->next)
811     verify_cgraph_node (node);
812 }
813
814 /* Output all asm statements we have stored up to be output.  */
815
816 static void
817 cgraph_output_pending_asms (void)
818 {
819   struct cgraph_asm_node *can;
820
821   if (errorcount || sorrycount)
822     return;
823
824   for (can = cgraph_asm_nodes; can; can = can->next)
825     assemble_asm (can->asm_str);
826   cgraph_asm_nodes = NULL;
827 }
828
829 /* Analyze the function scheduled to be output.  */
830 static void
831 cgraph_analyze_function (struct cgraph_node *node)
832 {
833   tree save = current_function_decl;
834   tree decl = node->decl;
835
836   current_function_decl = decl;
837   push_cfun (DECL_STRUCT_FUNCTION (decl));
838
839   /* Make sure to gimplify bodies only once.  During analyzing a
840      function we lower it, which will require gimplified nested
841      functions, so we can end up here with an already gimplified
842      body.  */
843   if (!gimple_body (decl))
844     gimplify_function_tree (decl);
845   dump_function (TDI_generic, decl);
846
847   cgraph_lower_function (node);
848   node->analyzed = true;
849
850   pop_cfun ();
851   current_function_decl = save;
852 }
853
854 /* Look for externally_visible and used attributes and mark cgraph nodes
855    accordingly.
856
857    We cannot mark the nodes at the point the attributes are processed (in
858    handle_*_attribute) because the copy of the declarations available at that
859    point may not be canonical.  For example, in:
860
861     void f();
862     void f() __attribute__((used));
863
864    the declaration we see in handle_used_attribute will be the second
865    declaration -- but the front end will subsequently merge that declaration
866    with the original declaration and discard the second declaration.
867
868    Furthermore, we can't mark these nodes in cgraph_finalize_function because:
869
870     void f() {}
871     void f() __attribute__((externally_visible));
872
873    is valid.
874
875    So, we walk the nodes at the end of the translation unit, applying the
876    attributes at that point.  */
877
878 static void
879 process_function_and_variable_attributes (struct cgraph_node *first,
880                                           struct varpool_node *first_var)
881 {
882   struct cgraph_node *node;
883   struct varpool_node *vnode;
884
885   for (node = cgraph_nodes; node != first; node = node->next)
886     {
887       tree decl = node->decl;
888       if (DECL_PRESERVE_P (decl))
889         {
890           mark_decl_referenced (decl);
891           if (node->local.finalized)
892              cgraph_mark_needed_node (node);
893         }
894       if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl)))
895         {
896           if (! TREE_PUBLIC (node->decl))
897             warning_at (DECL_SOURCE_LOCATION (node->decl), OPT_Wattributes,
898                         "%<externally_visible%>"
899                         " attribute have effect only on public objects");
900           else if (node->local.finalized)
901              cgraph_mark_needed_node (node);
902         }
903     }
904   for (vnode = varpool_nodes; vnode != first_var; vnode = vnode->next)
905     {
906       tree decl = vnode->decl;
907       if (DECL_PRESERVE_P (decl))
908         {
909           mark_decl_referenced (decl);
910           vnode->force_output = true;
911           if (vnode->finalized)
912             varpool_mark_needed_node (vnode);
913         }
914       if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl)))
915         {
916           if (! TREE_PUBLIC (vnode->decl))
917             warning_at (DECL_SOURCE_LOCATION (vnode->decl), OPT_Wattributes,
918                         "%<externally_visible%>"
919                         " attribute have effect only on public objects");
920           else if (vnode->finalized)
921             varpool_mark_needed_node (vnode);
922         }
923     }
924 }
925
926 /* Process CGRAPH_NODES_NEEDED queue, analyze each function (and transitively
927    each reachable functions) and build cgraph.
928    The function can be called multiple times after inserting new nodes
929    into beginning of queue.  Just the new part of queue is re-scanned then.  */
930
931 static void
932 cgraph_analyze_functions (void)
933 {
934   /* Keep track of already processed nodes when called multiple times for
935      intermodule optimization.  */
936   static struct cgraph_node *first_analyzed;
937   struct cgraph_node *first_processed = first_analyzed;
938   static struct varpool_node *first_analyzed_var;
939   struct cgraph_node *node, *next;
940
941   process_function_and_variable_attributes (first_processed,
942                                             first_analyzed_var);
943   first_processed = cgraph_nodes;
944   first_analyzed_var = varpool_nodes;
945   varpool_analyze_pending_decls ();
946   if (cgraph_dump_file)
947     {
948       fprintf (cgraph_dump_file, "Initial entry points:");
949       for (node = cgraph_nodes; node != first_analyzed; node = node->next)
950         if (node->needed)
951           fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
952       fprintf (cgraph_dump_file, "\n");
953     }
954   cgraph_process_new_functions ();
955
956   /* Propagate reachability flag and lower representation of all reachable
957      functions.  In the future, lowering will introduce new functions and
958      new entry points on the way (by template instantiation and virtual
959      method table generation for instance).  */
960   while (cgraph_nodes_queue)
961     {
962       struct cgraph_edge *edge;
963       tree decl = cgraph_nodes_queue->decl;
964
965       node = cgraph_nodes_queue;
966       cgraph_nodes_queue = cgraph_nodes_queue->next_needed;
967       node->next_needed = NULL;
968
969       /* ??? It is possible to create extern inline function and later using
970          weak alias attribute to kill its body. See
971          gcc.c-torture/compile/20011119-1.c  */
972       if (!DECL_STRUCT_FUNCTION (decl))
973         {
974           cgraph_reset_node (node);
975           continue;
976         }
977
978       if (!node->analyzed)
979         cgraph_analyze_function (node);
980
981       for (edge = node->callees; edge; edge = edge->next_callee)
982         if (!edge->callee->reachable)
983           cgraph_mark_reachable_node (edge->callee);
984
985       if (node->same_comdat_group)
986         {
987           for (next = node->same_comdat_group;
988                next != node;
989                next = next->same_comdat_group)
990             cgraph_mark_reachable_node (next);
991         }
992
993       /* If decl is a clone of an abstract function, mark that abstract
994          function so that we don't release its body. The DECL_INITIAL() of that
995          abstract function declaration will be later needed to output debug info.  */
996       if (DECL_ABSTRACT_ORIGIN (decl))
997         {
998           struct cgraph_node *origin_node = cgraph_node (DECL_ABSTRACT_ORIGIN (decl));
999           origin_node->abstract_and_needed = true;
1000         }
1001
1002       /* We finalize local static variables during constructing callgraph
1003          edges.  Process their attributes too.  */
1004       process_function_and_variable_attributes (first_processed,
1005                                                 first_analyzed_var);
1006       first_processed = cgraph_nodes;
1007       first_analyzed_var = varpool_nodes;
1008       varpool_analyze_pending_decls ();
1009       cgraph_process_new_functions ();
1010     }
1011
1012   /* Collect entry points to the unit.  */
1013   if (cgraph_dump_file)
1014     {
1015       fprintf (cgraph_dump_file, "Unit entry points:");
1016       for (node = cgraph_nodes; node != first_analyzed; node = node->next)
1017         if (node->needed)
1018           fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
1019       fprintf (cgraph_dump_file, "\n\nInitial ");
1020       dump_cgraph (cgraph_dump_file);
1021     }
1022
1023   if (cgraph_dump_file)
1024     fprintf (cgraph_dump_file, "\nReclaiming functions:");
1025
1026   for (node = cgraph_nodes; node != first_analyzed; node = next)
1027     {
1028       tree decl = node->decl;
1029       next = node->next;
1030
1031       if (node->local.finalized && !gimple_has_body_p (decl))
1032         cgraph_reset_node (node);
1033
1034       if (!node->reachable && gimple_has_body_p (decl))
1035         {
1036           if (cgraph_dump_file)
1037             fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
1038           cgraph_remove_node (node);
1039           continue;
1040         }
1041       else
1042         node->next_needed = NULL;
1043       gcc_assert (!node->local.finalized || gimple_has_body_p (decl));
1044       gcc_assert (node->analyzed == node->local.finalized);
1045     }
1046   if (cgraph_dump_file)
1047     {
1048       fprintf (cgraph_dump_file, "\n\nReclaimed ");
1049       dump_cgraph (cgraph_dump_file);
1050     }
1051   first_analyzed = cgraph_nodes;
1052   ggc_collect ();
1053 }
1054
1055
1056 /* Analyze the whole compilation unit once it is parsed completely.  */
1057
1058 void
1059 cgraph_finalize_compilation_unit (void)
1060 {
1061   timevar_push (TV_CGRAPH);
1062
1063   /* Do not skip analyzing the functions if there were errors, we
1064      miss diagnostics for following functions otherwise.  */
1065
1066   /* Emit size functions we didn't inline.  */
1067   finalize_size_functions ();
1068
1069   /* Call functions declared with the "constructor" or "destructor"
1070      attribute.  */
1071   cgraph_build_cdtor_fns ();
1072
1073   /* Mark alias targets necessary and emit diagnostics.  */
1074   finish_aliases_1 ();
1075
1076   if (!quiet_flag)
1077     {
1078       fprintf (stderr, "\nAnalyzing compilation unit\n");
1079       fflush (stderr);
1080     }
1081
1082   /* Gimplify and lower all functions, compute reachability and
1083      remove unreachable nodes.  */
1084   cgraph_analyze_functions ();
1085
1086   /* Mark alias targets necessary and emit diagnostics.  */
1087   finish_aliases_1 ();
1088
1089   /* Gimplify and lower thunks.  */
1090   cgraph_analyze_functions ();
1091
1092   /* Finally drive the pass manager.  */
1093   cgraph_optimize ();
1094
1095   timevar_pop (TV_CGRAPH);
1096 }
1097
1098
1099 /* Figure out what functions we want to assemble.  */
1100
1101 static void
1102 cgraph_mark_functions_to_output (void)
1103 {
1104   struct cgraph_node *node;
1105 #ifdef ENABLE_CHECKING
1106   bool check_same_comdat_groups = false;
1107
1108   for (node = cgraph_nodes; node; node = node->next)
1109     gcc_assert (!node->process);
1110 #endif
1111
1112   for (node = cgraph_nodes; node; node = node->next)
1113     {
1114       tree decl = node->decl;
1115       struct cgraph_edge *e;
1116
1117       gcc_assert (!node->process || node->same_comdat_group);
1118       if (node->process)
1119         continue;
1120
1121       for (e = node->callers; e; e = e->next_caller)
1122         if (e->inline_failed)
1123           break;
1124
1125       /* We need to output all local functions that are used and not
1126          always inlined, as well as those that are reachable from
1127          outside the current compilation unit.  */
1128       if (node->analyzed
1129           && !node->global.inlined_to
1130           && (node->needed
1131               || (e && node->reachable))
1132           && !TREE_ASM_WRITTEN (decl)
1133           && !DECL_EXTERNAL (decl))
1134         {
1135           node->process = 1;
1136           if (node->same_comdat_group)
1137             {
1138               struct cgraph_node *next;
1139               for (next = node->same_comdat_group;
1140                    next != node;
1141                    next = next->same_comdat_group)
1142                 next->process = 1;
1143             }
1144         }
1145       else if (node->same_comdat_group)
1146         {
1147 #ifdef ENABLE_CHECKING
1148           check_same_comdat_groups = true;
1149 #endif
1150         }
1151       else
1152         {
1153           /* We should've reclaimed all functions that are not needed.  */
1154 #ifdef ENABLE_CHECKING
1155           if (!node->global.inlined_to
1156               && gimple_has_body_p (decl)
1157               && !DECL_EXTERNAL (decl))
1158             {
1159               dump_cgraph_node (stderr, node);
1160               internal_error ("failed to reclaim unneeded function");
1161             }
1162 #endif
1163           gcc_assert (node->global.inlined_to
1164                       || !gimple_has_body_p (decl)
1165                       || DECL_EXTERNAL (decl));
1166
1167         }
1168
1169     }
1170 #ifdef ENABLE_CHECKING
1171   if (check_same_comdat_groups)
1172     for (node = cgraph_nodes; node; node = node->next)
1173       if (node->same_comdat_group && !node->process)
1174         {
1175           tree decl = node->decl;
1176           if (!node->global.inlined_to
1177               && gimple_has_body_p (decl)
1178               && !DECL_EXTERNAL (decl))
1179             {
1180               dump_cgraph_node (stderr, node);
1181               internal_error ("failed to reclaim unneeded function");
1182             }
1183         }
1184 #endif
1185 }
1186
1187 /* DECL is FUNCTION_DECL.  Initialize datastructures so DECL is a function
1188    in lowered gimple form.
1189    
1190    Set current_function_decl and cfun to newly constructed empty function body.
1191    return basic block in the function body.  */
1192
1193 static basic_block
1194 init_lowered_empty_function (tree decl)
1195 {
1196   basic_block bb;
1197
1198   current_function_decl = decl;
1199   allocate_struct_function (decl, false);
1200   gimple_register_cfg_hooks ();
1201   init_empty_tree_cfg ();
1202   init_tree_ssa (cfun);
1203   init_ssa_operands ();
1204   cfun->gimple_df->in_ssa_p = true;
1205   DECL_INITIAL (decl) = make_node (BLOCK);
1206
1207   DECL_SAVED_TREE (decl) = error_mark_node;
1208   cfun->curr_properties |=
1209     (PROP_gimple_lcf | PROP_gimple_leh | PROP_cfg | PROP_referenced_vars |
1210      PROP_ssa);
1211
1212   /* Create BB for body of the function and connect it properly.  */
1213   bb = create_basic_block (NULL, (void *) 0, ENTRY_BLOCK_PTR);
1214   make_edge (ENTRY_BLOCK_PTR, bb, 0);
1215   make_edge (bb, EXIT_BLOCK_PTR, 0);
1216
1217   return bb;
1218 }
1219
1220 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
1221    offset indicated by VIRTUAL_OFFSET, if that is
1222    non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
1223    zero for a result adjusting thunk.  */
1224
1225 static tree
1226 thunk_adjust (gimple_stmt_iterator * bsi,
1227               tree ptr, bool this_adjusting,
1228               HOST_WIDE_INT fixed_offset, tree virtual_offset)
1229 {
1230   gimple stmt;
1231   tree ret;
1232
1233   if (this_adjusting
1234       && fixed_offset != 0)
1235     {
1236       stmt = gimple_build_assign (ptr,
1237                                   fold_build2_loc (input_location,
1238                                                    POINTER_PLUS_EXPR,
1239                                                    TREE_TYPE (ptr), ptr,
1240                                                    size_int (fixed_offset)));
1241       gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1242     }
1243
1244   /* If there's a virtual offset, look up that value in the vtable and
1245      adjust the pointer again.  */
1246   if (virtual_offset)
1247     {
1248       tree vtabletmp;
1249       tree vtabletmp2;
1250       tree vtabletmp3;
1251       tree offsettmp;
1252
1253       if (!vtable_entry_type)
1254         {
1255           tree vfunc_type = make_node (FUNCTION_TYPE);
1256           TREE_TYPE (vfunc_type) = integer_type_node;
1257           TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
1258           layout_type (vfunc_type);
1259
1260           vtable_entry_type = build_pointer_type (vfunc_type);
1261         }
1262
1263       vtabletmp =
1264         create_tmp_var (build_pointer_type
1265                         (build_pointer_type (vtable_entry_type)), "vptr");
1266
1267       /* The vptr is always at offset zero in the object.  */
1268       stmt = gimple_build_assign (vtabletmp,
1269                                   build1 (NOP_EXPR, TREE_TYPE (vtabletmp),
1270                                           ptr));
1271       gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1272       mark_symbols_for_renaming (stmt);
1273       find_referenced_vars_in (stmt);
1274
1275       /* Form the vtable address.  */
1276       vtabletmp2 = create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp)),
1277                                    "vtableaddr");
1278       stmt = gimple_build_assign (vtabletmp2,
1279                                   build1 (INDIRECT_REF,
1280                                           TREE_TYPE (vtabletmp2), vtabletmp));
1281       gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1282       mark_symbols_for_renaming (stmt);
1283       find_referenced_vars_in (stmt);
1284
1285       /* Find the entry with the vcall offset.  */
1286       stmt = gimple_build_assign (vtabletmp2,
1287                                   fold_build2_loc (input_location,
1288                                                    POINTER_PLUS_EXPR,
1289                                                    TREE_TYPE (vtabletmp2),
1290                                                    vtabletmp2,
1291                                                    fold_convert (sizetype,
1292                                                                  virtual_offset)));
1293       gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1294
1295       /* Get the offset itself.  */
1296       vtabletmp3 = create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp2)),
1297                                    "vcalloffset");
1298       stmt = gimple_build_assign (vtabletmp3,
1299                                   build1 (INDIRECT_REF,
1300                                           TREE_TYPE (vtabletmp3),
1301                                           vtabletmp2));
1302       gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1303       mark_symbols_for_renaming (stmt);
1304       find_referenced_vars_in (stmt);
1305
1306       /* Cast to sizetype.  */
1307       offsettmp = create_tmp_var (sizetype, "offset");
1308       stmt = gimple_build_assign (offsettmp, fold_convert (sizetype, vtabletmp3));
1309       gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1310       mark_symbols_for_renaming (stmt);
1311       find_referenced_vars_in (stmt);
1312
1313       /* Adjust the `this' pointer.  */
1314       ptr = fold_build2_loc (input_location,
1315                              POINTER_PLUS_EXPR, TREE_TYPE (ptr), ptr,
1316                              offsettmp);
1317     }
1318
1319   if (!this_adjusting
1320       && fixed_offset != 0)
1321     /* Adjust the pointer by the constant.  */
1322     {
1323       tree ptrtmp;
1324
1325       if (TREE_CODE (ptr) == VAR_DECL)
1326         ptrtmp = ptr;
1327       else
1328         {
1329           ptrtmp = create_tmp_var (TREE_TYPE (ptr), "ptr");
1330           stmt = gimple_build_assign (ptrtmp, ptr);
1331           gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1332           mark_symbols_for_renaming (stmt);
1333           find_referenced_vars_in (stmt);
1334         }
1335       ptr = fold_build2_loc (input_location,
1336                              POINTER_PLUS_EXPR, TREE_TYPE (ptrtmp), ptrtmp,
1337                              size_int (fixed_offset));
1338     }
1339
1340   /* Emit the statement and gimplify the adjustment expression.  */
1341   ret = create_tmp_var (TREE_TYPE (ptr), "adjusted_this");
1342   stmt = gimple_build_assign (ret, ptr);
1343   mark_symbols_for_renaming (stmt);
1344   find_referenced_vars_in (stmt);
1345   gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1346
1347   return ret;
1348 }
1349
1350 /* Produce assembler for thunk NODE.  */
1351
1352 static void
1353 assemble_thunk (struct cgraph_node *node)
1354 {
1355   bool this_adjusting = node->thunk.this_adjusting;
1356   HOST_WIDE_INT fixed_offset = node->thunk.fixed_offset;
1357   HOST_WIDE_INT virtual_value = node->thunk.virtual_value;
1358   tree virtual_offset = NULL;
1359   tree alias = node->thunk.alias;
1360   tree thunk_fndecl = node->decl;
1361   tree a = DECL_ARGUMENTS (thunk_fndecl);
1362
1363   current_function_decl = thunk_fndecl;
1364
1365   if (this_adjusting
1366       && targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
1367                                               virtual_value, alias))
1368     {
1369       const char *fnname;
1370       tree fn_block;
1371       
1372       DECL_RESULT (thunk_fndecl)
1373         = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl),
1374                       RESULT_DECL, 0, integer_type_node);
1375       fnname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk_fndecl));
1376
1377       /* The back end expects DECL_INITIAL to contain a BLOCK, so we
1378          create one.  */
1379       fn_block = make_node (BLOCK);
1380       BLOCK_VARS (fn_block) = a;
1381       DECL_INITIAL (thunk_fndecl) = fn_block;
1382       init_function_start (thunk_fndecl);
1383       cfun->is_thunk = 1;
1384       assemble_start_function (thunk_fndecl, fnname);
1385
1386       targetm.asm_out.output_mi_thunk (asm_out_file, thunk_fndecl,
1387                                        fixed_offset, virtual_value, alias);
1388
1389       assemble_end_function (thunk_fndecl, fnname);
1390       init_insn_lengths ();
1391       free_after_compilation (cfun);
1392       set_cfun (NULL);
1393       TREE_ASM_WRITTEN (thunk_fndecl) = 1;
1394     }
1395   else
1396     {
1397       tree restype;
1398       basic_block bb, then_bb, else_bb, return_bb;
1399       gimple_stmt_iterator bsi;
1400       int nargs = 0;
1401       tree arg;
1402       int i;
1403       tree resdecl;
1404       tree restmp = NULL;
1405       VEC(tree, heap) *vargs;
1406
1407       gimple call;
1408       gimple ret;
1409
1410       DECL_IGNORED_P (thunk_fndecl) = 1;
1411       bitmap_obstack_initialize (NULL);
1412
1413       if (node->thunk.virtual_offset_p)
1414         virtual_offset = size_int (virtual_value);
1415
1416       /* Build the return declaration for the function.  */
1417       restype = TREE_TYPE (TREE_TYPE (thunk_fndecl));
1418       if (DECL_RESULT (thunk_fndecl) == NULL_TREE)
1419         {
1420           resdecl = build_decl (input_location, RESULT_DECL, 0, restype);
1421           DECL_ARTIFICIAL (resdecl) = 1;
1422           DECL_IGNORED_P (resdecl) = 1;
1423           DECL_RESULT (thunk_fndecl) = resdecl;
1424         }
1425       else
1426         resdecl = DECL_RESULT (thunk_fndecl);
1427
1428       bb = then_bb = else_bb = return_bb = init_lowered_empty_function (thunk_fndecl);
1429
1430       bsi = gsi_start_bb (bb);
1431
1432       /* Build call to the function being thunked.  */
1433       if (!VOID_TYPE_P (restype))
1434         {
1435           if (!is_gimple_reg_type (restype))
1436             {
1437               restmp = resdecl;
1438               cfun->local_decls = tree_cons (NULL_TREE, restmp, cfun->local_decls);
1439               BLOCK_VARS (DECL_INITIAL (current_function_decl)) = restmp;
1440             }
1441           else
1442             restmp = create_tmp_var_raw (restype, "retval");
1443         }
1444
1445       for (arg = a; arg; arg = TREE_CHAIN (arg))
1446         nargs++;
1447       vargs = VEC_alloc (tree, heap, nargs);
1448       if (this_adjusting)
1449         VEC_quick_push (tree, vargs,
1450                         thunk_adjust (&bsi,
1451                                       a, 1, fixed_offset,
1452                                       virtual_offset));
1453       else
1454         VEC_quick_push (tree, vargs, a);
1455       for (i = 1, arg = TREE_CHAIN (a); i < nargs; i++, arg = TREE_CHAIN (arg))
1456         VEC_quick_push (tree, vargs, arg);
1457       call = gimple_build_call_vec (build_fold_addr_expr_loc (0, alias), vargs);
1458       VEC_free (tree, heap, vargs);
1459       gimple_call_set_cannot_inline (call, true);
1460       gimple_call_set_from_thunk (call, true);
1461       if (restmp)
1462         gimple_call_set_lhs (call, restmp);
1463       gsi_insert_after (&bsi, call, GSI_NEW_STMT);
1464       mark_symbols_for_renaming (call);
1465       find_referenced_vars_in (call);
1466       update_stmt (call);
1467
1468       if (restmp && !this_adjusting)
1469         {
1470           tree true_label = NULL_TREE;
1471
1472           if (TREE_CODE (TREE_TYPE (restmp)) == POINTER_TYPE)
1473             {
1474               gimple stmt;
1475               /* If the return type is a pointer, we need to
1476                  protect against NULL.  We know there will be an
1477                  adjustment, because that's why we're emitting a
1478                  thunk.  */
1479               then_bb = create_basic_block (NULL, (void *) 0, bb);
1480               return_bb = create_basic_block (NULL, (void *) 0, then_bb);
1481               else_bb = create_basic_block (NULL, (void *) 0, else_bb);
1482               remove_edge (single_succ_edge (bb));
1483               true_label = gimple_block_label (then_bb);
1484               stmt = gimple_build_cond (NE_EXPR, restmp,
1485                                         fold_convert (TREE_TYPE (restmp),
1486                                                       integer_zero_node),
1487                                         NULL_TREE, NULL_TREE);
1488               gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
1489               make_edge (bb, then_bb, EDGE_TRUE_VALUE);
1490               make_edge (bb, else_bb, EDGE_FALSE_VALUE);
1491               make_edge (return_bb, EXIT_BLOCK_PTR, 0);
1492               make_edge (then_bb, return_bb, EDGE_FALLTHRU);
1493               make_edge (else_bb, return_bb, EDGE_FALLTHRU);
1494               bsi = gsi_last_bb (then_bb);
1495             }
1496
1497           restmp = thunk_adjust (&bsi, restmp, /*this_adjusting=*/0,
1498                                  fixed_offset, virtual_offset);
1499           if (true_label)
1500             {
1501               gimple stmt;
1502               bsi = gsi_last_bb (else_bb);
1503               stmt = gimple_build_assign (restmp, fold_convert (TREE_TYPE (restmp),
1504                                                                 integer_zero_node));
1505               gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
1506               bsi = gsi_last_bb (return_bb);
1507             }
1508         }
1509       else
1510         gimple_call_set_tail (call, true);
1511
1512       /* Build return value.  */
1513       ret = gimple_build_return (restmp);
1514       gsi_insert_after (&bsi, ret, GSI_NEW_STMT);
1515
1516       delete_unreachable_blocks ();
1517       update_ssa (TODO_update_ssa);
1518
1519       cgraph_remove_same_body_alias (node);
1520       /* Since we want to emit the thunk, we explicitly mark its name as
1521          referenced.  */
1522       mark_decl_referenced (thunk_fndecl);
1523       cgraph_add_new_function (thunk_fndecl, true);
1524       bitmap_obstack_release (NULL);
1525     }
1526   current_function_decl = NULL;
1527 }
1528
1529 /* Expand function specified by NODE.  */
1530
1531 static void
1532 cgraph_expand_function (struct cgraph_node *node)
1533 {
1534   tree decl = node->decl;
1535
1536   /* We ought to not compile any inline clones.  */
1537   gcc_assert (!node->global.inlined_to);
1538
1539   announce_function (decl);
1540   node->process = 0;
1541
1542   gcc_assert (node->lowered);
1543
1544   /* Generate RTL for the body of DECL.  */
1545   tree_rest_of_compilation (decl);
1546
1547   /* Make sure that BE didn't give up on compiling.  */
1548   gcc_assert (TREE_ASM_WRITTEN (decl));
1549   current_function_decl = NULL;
1550   if (node->same_body)
1551     {
1552       struct cgraph_node *alias, *next;
1553       bool saved_alias = node->alias;
1554       for (alias = node->same_body;
1555            alias && alias->next; alias = alias->next)
1556         ;
1557       /* Walk aliases in the order they were created; it is possible that
1558          thunks reffers to the aliases made earlier.  */
1559       for (; alias; alias = next)
1560         {
1561           next = alias->previous;
1562           if (!alias->thunk.thunk_p)
1563             assemble_alias (alias->decl,
1564                             DECL_ASSEMBLER_NAME (alias->thunk.alias));
1565           else
1566             assemble_thunk (alias);
1567         }
1568       node->alias = saved_alias;
1569     }
1570   gcc_assert (!cgraph_preserve_function_body_p (decl));
1571   cgraph_release_function_body (node);
1572   /* Eliminate all call edges.  This is important so the GIMPLE_CALL no longer
1573      points to the dead function body.  */
1574   cgraph_node_remove_callees (node);
1575
1576   cgraph_function_flags_ready = true;
1577 }
1578
1579 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL.  */
1580
1581 bool
1582 cgraph_inline_p (struct cgraph_edge *e, cgraph_inline_failed_t *reason)
1583 {
1584   *reason = e->inline_failed;
1585   return !e->inline_failed;
1586 }
1587
1588
1589
1590 /* Expand all functions that must be output.
1591
1592    Attempt to topologically sort the nodes so function is output when
1593    all called functions are already assembled to allow data to be
1594    propagated across the callgraph.  Use a stack to get smaller distance
1595    between a function and its callees (later we may choose to use a more
1596    sophisticated algorithm for function reordering; we will likely want
1597    to use subsections to make the output functions appear in top-down
1598    order).  */
1599
1600 static void
1601 cgraph_expand_all_functions (void)
1602 {
1603   struct cgraph_node *node;
1604   struct cgraph_node **order = XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
1605   int order_pos, new_order_pos = 0;
1606   int i;
1607
1608   order_pos = cgraph_postorder (order);
1609   gcc_assert (order_pos == cgraph_n_nodes);
1610
1611   /* Garbage collector may remove inline clones we eliminate during
1612      optimization.  So we must be sure to not reference them.  */
1613   for (i = 0; i < order_pos; i++)
1614     if (order[i]->process)
1615       order[new_order_pos++] = order[i];
1616
1617   for (i = new_order_pos - 1; i >= 0; i--)
1618     {
1619       node = order[i];
1620       if (node->process)
1621         {
1622           gcc_assert (node->reachable);
1623           node->process = 0;
1624           cgraph_expand_function (node);
1625         }
1626     }
1627   cgraph_process_new_functions ();
1628
1629   free (order);
1630
1631 }
1632
1633 /* This is used to sort the node types by the cgraph order number.  */
1634
1635 enum cgraph_order_sort_kind
1636 {
1637   ORDER_UNDEFINED = 0,
1638   ORDER_FUNCTION,
1639   ORDER_VAR,
1640   ORDER_ASM
1641 };
1642
1643 struct cgraph_order_sort
1644 {
1645   enum cgraph_order_sort_kind kind;
1646   union
1647   {
1648     struct cgraph_node *f;
1649     struct varpool_node *v;
1650     struct cgraph_asm_node *a;
1651   } u;
1652 };
1653
1654 /* Output all functions, variables, and asm statements in the order
1655    according to their order fields, which is the order in which they
1656    appeared in the file.  This implements -fno-toplevel-reorder.  In
1657    this mode we may output functions and variables which don't really
1658    need to be output.  */
1659
1660 static void
1661 cgraph_output_in_order (void)
1662 {
1663   int max;
1664   size_t size;
1665   struct cgraph_order_sort *nodes;
1666   int i;
1667   struct cgraph_node *pf;
1668   struct varpool_node *pv;
1669   struct cgraph_asm_node *pa;
1670
1671   max = cgraph_order;
1672   size = max * sizeof (struct cgraph_order_sort);
1673   nodes = (struct cgraph_order_sort *) alloca (size);
1674   memset (nodes, 0, size);
1675
1676   varpool_analyze_pending_decls ();
1677
1678   for (pf = cgraph_nodes; pf; pf = pf->next)
1679     {
1680       if (pf->process)
1681         {
1682           i = pf->order;
1683           gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1684           nodes[i].kind = ORDER_FUNCTION;
1685           nodes[i].u.f = pf;
1686         }
1687     }
1688
1689   for (pv = varpool_nodes_queue; pv; pv = pv->next_needed)
1690     {
1691       i = pv->order;
1692       gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1693       nodes[i].kind = ORDER_VAR;
1694       nodes[i].u.v = pv;
1695     }
1696
1697   for (pa = cgraph_asm_nodes; pa; pa = pa->next)
1698     {
1699       i = pa->order;
1700       gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1701       nodes[i].kind = ORDER_ASM;
1702       nodes[i].u.a = pa;
1703     }
1704
1705   /* In toplevel reorder mode we output all statics; mark them as needed.  */
1706   for (i = 0; i < max; ++i)
1707     {
1708       if (nodes[i].kind == ORDER_VAR)
1709         {
1710           varpool_mark_needed_node (nodes[i].u.v);
1711         }
1712     }
1713   varpool_empty_needed_queue ();
1714
1715   for (i = 0; i < max; ++i)
1716     {
1717       switch (nodes[i].kind)
1718         {
1719         case ORDER_FUNCTION:
1720           nodes[i].u.f->process = 0;
1721           cgraph_expand_function (nodes[i].u.f);
1722           break;
1723
1724         case ORDER_VAR:
1725           varpool_assemble_decl (nodes[i].u.v);
1726           break;
1727
1728         case ORDER_ASM:
1729           assemble_asm (nodes[i].u.a->asm_str);
1730           break;
1731
1732         case ORDER_UNDEFINED:
1733           break;
1734
1735         default:
1736           gcc_unreachable ();
1737         }
1738     }
1739
1740   cgraph_asm_nodes = NULL;
1741 }
1742
1743 /* Return true when function body of DECL still needs to be kept around
1744    for later re-use.  */
1745 bool
1746 cgraph_preserve_function_body_p (tree decl)
1747 {
1748   struct cgraph_node *node;
1749
1750   gcc_assert (cgraph_global_info_ready);
1751   /* Look if there is any clone around.  */
1752   node = cgraph_node (decl);
1753   if (node->clones)
1754     return true;
1755   return false;
1756 }
1757
1758 static void
1759 ipa_passes (void)
1760 {
1761   set_cfun (NULL);
1762   current_function_decl = NULL;
1763   gimple_register_cfg_hooks ();
1764   bitmap_obstack_initialize (NULL);
1765
1766   invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_START, NULL);
1767
1768   if (!in_lto_p)
1769     execute_ipa_pass_list (all_small_ipa_passes);
1770
1771   /* If pass_all_early_optimizations was not scheduled, the state of
1772      the cgraph will not be properly updated.  Update it now.  */
1773   if (cgraph_state < CGRAPH_STATE_IPA_SSA)
1774     cgraph_state = CGRAPH_STATE_IPA_SSA;
1775
1776   if (!in_lto_p)
1777     {
1778       /* Generate coverage variables and constructors.  */
1779       coverage_finish ();
1780
1781       /* Process new functions added.  */
1782       set_cfun (NULL);
1783       current_function_decl = NULL;
1784       cgraph_process_new_functions ();
1785
1786       execute_ipa_summary_passes
1787         ((struct ipa_opt_pass_d *) all_regular_ipa_passes);
1788     }
1789   execute_ipa_summary_passes ((struct ipa_opt_pass_d *) all_lto_gen_passes);
1790
1791   if (!in_lto_p)
1792     ipa_write_summaries ();
1793
1794   if (!flag_ltrans)
1795     execute_ipa_pass_list (all_regular_ipa_passes);
1796   invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_END, NULL);
1797
1798   bitmap_obstack_release (NULL);
1799 }
1800
1801
1802 /* Perform simple optimizations based on callgraph.  */
1803
1804 void
1805 cgraph_optimize (void)
1806 {
1807   if (errorcount || sorrycount)
1808     return;
1809
1810 #ifdef ENABLE_CHECKING
1811   verify_cgraph ();
1812 #endif
1813
1814   /* Frontend may output common variables after the unit has been finalized.
1815      It is safe to deal with them here as they are always zero initialized.  */
1816   varpool_analyze_pending_decls ();
1817
1818   timevar_push (TV_CGRAPHOPT);
1819   if (pre_ipa_mem_report)
1820     {
1821       fprintf (stderr, "Memory consumption before IPA\n");
1822       dump_memory_report (false);
1823     }
1824   if (!quiet_flag)
1825     fprintf (stderr, "Performing interprocedural optimizations\n");
1826   cgraph_state = CGRAPH_STATE_IPA;
1827
1828   /* Don't run the IPA passes if there was any error or sorry messages.  */
1829   if (errorcount == 0 && sorrycount == 0)
1830     ipa_passes ();
1831
1832   /* Do nothing else if any IPA pass found errors.  */
1833   if (errorcount || sorrycount)
1834     {
1835       timevar_pop (TV_CGRAPHOPT);
1836       return;
1837     }
1838
1839   /* This pass remove bodies of extern inline functions we never inlined.
1840      Do this later so other IPA passes see what is really going on.  */
1841   cgraph_remove_unreachable_nodes (false, dump_file);
1842   cgraph_global_info_ready = true;
1843   if (cgraph_dump_file)
1844     {
1845       fprintf (cgraph_dump_file, "Optimized ");
1846       dump_cgraph (cgraph_dump_file);
1847       dump_varpool (cgraph_dump_file);
1848     }
1849   if (post_ipa_mem_report)
1850     {
1851       fprintf (stderr, "Memory consumption after IPA\n");
1852       dump_memory_report (false);
1853     }
1854   timevar_pop (TV_CGRAPHOPT);
1855
1856   /* Output everything.  */
1857   (*debug_hooks->assembly_start) ();
1858   if (!quiet_flag)
1859     fprintf (stderr, "Assembling functions:\n");
1860 #ifdef ENABLE_CHECKING
1861   verify_cgraph ();
1862 #endif
1863
1864   cgraph_materialize_all_clones ();
1865   cgraph_mark_functions_to_output ();
1866
1867   cgraph_state = CGRAPH_STATE_EXPANSION;
1868   if (!flag_toplevel_reorder)
1869     cgraph_output_in_order ();
1870   else
1871     {
1872       cgraph_output_pending_asms ();
1873
1874       cgraph_expand_all_functions ();
1875       varpool_remove_unreferenced_decls ();
1876
1877       varpool_assemble_pending_decls ();
1878     }
1879   cgraph_process_new_functions ();
1880   cgraph_state = CGRAPH_STATE_FINISHED;
1881
1882   if (cgraph_dump_file)
1883     {
1884       fprintf (cgraph_dump_file, "\nFinal ");
1885       dump_cgraph (cgraph_dump_file);
1886     }
1887 #ifdef ENABLE_CHECKING
1888   verify_cgraph ();
1889   /* Double check that all inline clones are gone and that all
1890      function bodies have been released from memory.  */
1891   if (!(sorrycount || errorcount))
1892     {
1893       struct cgraph_node *node;
1894       bool error_found = false;
1895
1896       for (node = cgraph_nodes; node; node = node->next)
1897         if (node->analyzed
1898             && (node->global.inlined_to
1899                 || gimple_has_body_p (node->decl)))
1900           {
1901             error_found = true;
1902             dump_cgraph_node (stderr, node);
1903           }
1904       if (error_found)
1905         internal_error ("nodes with unreleased memory found");
1906     }
1907 #endif
1908 }
1909
1910
1911 /* Generate and emit a static constructor or destructor.  WHICH must
1912    be one of 'I' (for a constructor) or 'D' (for a destructor).  BODY
1913    is a STATEMENT_LIST containing GENERIC statements.  PRIORITY is the
1914    initialization priority for this constructor or destructor.  */
1915
1916 void
1917 cgraph_build_static_cdtor (char which, tree body, int priority)
1918 {
1919   static int counter = 0;
1920   char which_buf[16];
1921   tree decl, name, resdecl;
1922
1923   /* The priority is encoded in the constructor or destructor name.
1924      collect2 will sort the names and arrange that they are called at
1925      program startup.  */
1926   sprintf (which_buf, "%c_%.5d_%d", which, priority, counter++);
1927   name = get_file_function_name (which_buf);
1928
1929   decl = build_decl (input_location, FUNCTION_DECL, name,
1930                      build_function_type (void_type_node, void_list_node));
1931   current_function_decl = decl;
1932
1933   resdecl = build_decl (input_location,
1934                         RESULT_DECL, NULL_TREE, void_type_node);
1935   DECL_ARTIFICIAL (resdecl) = 1;
1936   DECL_RESULT (decl) = resdecl;
1937   DECL_CONTEXT (resdecl) = decl;
1938
1939   allocate_struct_function (decl, false);
1940
1941   TREE_STATIC (decl) = 1;
1942   TREE_USED (decl) = 1;
1943   DECL_ARTIFICIAL (decl) = 1;
1944   DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
1945   DECL_SAVED_TREE (decl) = body;
1946   TREE_PUBLIC (decl) = ! targetm.have_ctors_dtors;
1947   DECL_UNINLINABLE (decl) = 1;
1948
1949   DECL_INITIAL (decl) = make_node (BLOCK);
1950   TREE_USED (DECL_INITIAL (decl)) = 1;
1951
1952   DECL_SOURCE_LOCATION (decl) = input_location;
1953   cfun->function_end_locus = input_location;
1954
1955   switch (which)
1956     {
1957     case 'I':
1958       DECL_STATIC_CONSTRUCTOR (decl) = 1;
1959       decl_init_priority_insert (decl, priority);
1960       break;
1961     case 'D':
1962       DECL_STATIC_DESTRUCTOR (decl) = 1;
1963       decl_fini_priority_insert (decl, priority);
1964       break;
1965     default:
1966       gcc_unreachable ();
1967     }
1968
1969   gimplify_function_tree (decl);
1970
1971   cgraph_add_new_function (decl, false);
1972   cgraph_mark_needed_node (cgraph_node (decl));
1973   set_cfun (NULL);
1974 }
1975
1976 void
1977 init_cgraph (void)
1978 {
1979   cgraph_dump_file = dump_begin (TDI_cgraph, NULL);
1980 }
1981
1982 /* The edges representing the callers of the NEW_VERSION node were
1983    fixed by cgraph_function_versioning (), now the call_expr in their
1984    respective tree code should be updated to call the NEW_VERSION.  */
1985
1986 static void
1987 update_call_expr (struct cgraph_node *new_version)
1988 {
1989   struct cgraph_edge *e;
1990
1991   gcc_assert (new_version);
1992
1993   /* Update the call expr on the edges to call the new version.  */
1994   for (e = new_version->callers; e; e = e->next_caller)
1995     {
1996       struct function *inner_function = DECL_STRUCT_FUNCTION (e->caller->decl);
1997       gimple_call_set_fndecl (e->call_stmt, new_version->decl);
1998       maybe_clean_eh_stmt_fn (inner_function, e->call_stmt);
1999     }
2000 }
2001
2002
2003 /* Create a new cgraph node which is the new version of
2004    OLD_VERSION node.  REDIRECT_CALLERS holds the callers
2005    edges which should be redirected to point to
2006    NEW_VERSION.  ALL the callees edges of OLD_VERSION
2007    are cloned to the new version node.  Return the new
2008    version node.  */
2009
2010 static struct cgraph_node *
2011 cgraph_copy_node_for_versioning (struct cgraph_node *old_version,
2012                                  tree new_decl,
2013                                  VEC(cgraph_edge_p,heap) *redirect_callers)
2014  {
2015    struct cgraph_node *new_version;
2016    struct cgraph_edge *e, *new_e;
2017    struct cgraph_edge *next_callee;
2018    unsigned i;
2019
2020    gcc_assert (old_version);
2021
2022    new_version = cgraph_node (new_decl);
2023
2024    new_version->analyzed = true;
2025    new_version->local = old_version->local;
2026    new_version->global = old_version->global;
2027    new_version->rtl = new_version->rtl;
2028    new_version->reachable = true;
2029    new_version->count = old_version->count;
2030
2031    /* Clone the old node callees.  Recursive calls are
2032       also cloned.  */
2033    for (e = old_version->callees;e; e=e->next_callee)
2034      {
2035        new_e = cgraph_clone_edge (e, new_version, e->call_stmt,
2036                                   e->lto_stmt_uid, 0, e->frequency,
2037                                   e->loop_nest, true);
2038        new_e->count = e->count;
2039      }
2040    /* Fix recursive calls.
2041       If OLD_VERSION has a recursive call after the
2042       previous edge cloning, the new version will have an edge
2043       pointing to the old version, which is wrong;
2044       Redirect it to point to the new version. */
2045    for (e = new_version->callees ; e; e = next_callee)
2046      {
2047        next_callee = e->next_callee;
2048        if (e->callee == old_version)
2049          cgraph_redirect_edge_callee (e, new_version);
2050
2051        if (!next_callee)
2052          break;
2053      }
2054    for (i = 0; VEC_iterate (cgraph_edge_p, redirect_callers, i, e); i++)
2055      {
2056        /* Redirect calls to the old version node to point to its new
2057           version.  */
2058        cgraph_redirect_edge_callee (e, new_version);
2059      }
2060
2061    return new_version;
2062  }
2063
2064  /* Perform function versioning.
2065     Function versioning includes copying of the tree and
2066     a callgraph update (creating a new cgraph node and updating
2067     its callees and callers).
2068
2069     REDIRECT_CALLERS varray includes the edges to be redirected
2070     to the new version.
2071
2072     TREE_MAP is a mapping of tree nodes we want to replace with
2073     new ones (according to results of prior analysis).
2074     OLD_VERSION_NODE is the node that is versioned.
2075     It returns the new version's cgraph node.
2076     ARGS_TO_SKIP lists arguments to be omitted from functions
2077     */
2078
2079 struct cgraph_node *
2080 cgraph_function_versioning (struct cgraph_node *old_version_node,
2081                             VEC(cgraph_edge_p,heap) *redirect_callers,
2082                             VEC (ipa_replace_map_p,gc)* tree_map,
2083                             bitmap args_to_skip)
2084 {
2085   tree old_decl = old_version_node->decl;
2086   struct cgraph_node *new_version_node = NULL;
2087   tree new_decl;
2088
2089   if (!tree_versionable_function_p (old_decl))
2090     return NULL;
2091
2092   /* Make a new FUNCTION_DECL tree node for the
2093      new version. */
2094   if (!args_to_skip)
2095     new_decl = copy_node (old_decl);
2096   else
2097     new_decl = build_function_decl_skip_args (old_decl, args_to_skip);
2098
2099   /* Create the new version's call-graph node.
2100      and update the edges of the new node. */
2101   new_version_node =
2102     cgraph_copy_node_for_versioning (old_version_node, new_decl,
2103                                      redirect_callers);
2104
2105   /* Copy the OLD_VERSION_NODE function tree to the new version.  */
2106   tree_function_versioning (old_decl, new_decl, tree_map, false, args_to_skip);
2107
2108   /* Update the new version's properties.
2109      Make The new version visible only within this translation unit.  Make sure
2110      that is not weak also.
2111      ??? We cannot use COMDAT linkage because there is no
2112      ABI support for this.  */
2113   cgraph_make_decl_local (new_version_node->decl);
2114   DECL_VIRTUAL_P (new_version_node->decl) = 0;
2115   new_version_node->local.externally_visible = 0;
2116   new_version_node->local.local = 1;
2117   new_version_node->lowered = true;
2118
2119   /* Update the call_expr on the edges to call the new version node. */
2120   update_call_expr (new_version_node);
2121
2122   cgraph_call_function_insertion_hooks (new_version_node);
2123   return new_version_node;
2124 }
2125
2126 /* Produce separate function body for inline clones so the offline copy can be
2127    modified without affecting them.  */
2128 struct cgraph_node *
2129 save_inline_function_body (struct cgraph_node *node)
2130 {
2131   struct cgraph_node *first_clone, *n;
2132
2133   gcc_assert (node == cgraph_node (node->decl));
2134
2135   cgraph_lower_function (node);
2136
2137   first_clone = node->clones;
2138
2139   first_clone->decl = copy_node (node->decl);
2140   cgraph_insert_node_to_hashtable (first_clone);
2141   gcc_assert (first_clone == cgraph_node (first_clone->decl));
2142   if (first_clone->next_sibling_clone)
2143     {
2144       for (n = first_clone->next_sibling_clone; n->next_sibling_clone; n = n->next_sibling_clone)
2145         n->clone_of = first_clone;
2146       n->clone_of = first_clone;
2147       n->next_sibling_clone = first_clone->clones;
2148       if (first_clone->clones)
2149         first_clone->clones->prev_sibling_clone = n;
2150       first_clone->clones = first_clone->next_sibling_clone;
2151       first_clone->next_sibling_clone->prev_sibling_clone = NULL;
2152       first_clone->next_sibling_clone = NULL;
2153       gcc_assert (!first_clone->prev_sibling_clone);
2154     }
2155   first_clone->clone_of = NULL;
2156   node->clones = NULL;
2157
2158   if (first_clone->clones)
2159     for (n = first_clone->clones; n != first_clone;)
2160       {
2161         gcc_assert (n->decl == node->decl);
2162         n->decl = first_clone->decl;
2163         if (n->clones)
2164           n = n->clones;
2165         else if (n->next_sibling_clone)
2166           n = n->next_sibling_clone;
2167         else
2168           {
2169             while (n != first_clone && !n->next_sibling_clone)
2170               n = n->clone_of;
2171             if (n != first_clone)
2172               n = n->next_sibling_clone;
2173           }
2174       }
2175
2176   /* Copy the OLD_VERSION_NODE function tree to the new version.  */
2177   tree_function_versioning (node->decl, first_clone->decl, NULL, true, NULL);
2178
2179   DECL_EXTERNAL (first_clone->decl) = 0;
2180   DECL_COMDAT_GROUP (first_clone->decl) = NULL_TREE;
2181   TREE_PUBLIC (first_clone->decl) = 0;
2182   DECL_COMDAT (first_clone->decl) = 0;
2183   VEC_free (ipa_opt_pass, heap,
2184             first_clone->ipa_transforms_to_apply);
2185   first_clone->ipa_transforms_to_apply = NULL;
2186
2187 #ifdef ENABLE_CHECKING
2188   verify_cgraph_node (first_clone);
2189 #endif
2190   return first_clone;
2191 }
2192
2193 /* Given virtual clone, turn it into actual clone.  */
2194 static void
2195 cgraph_materialize_clone (struct cgraph_node *node)
2196 {
2197   bitmap_obstack_initialize (NULL);
2198   /* Copy the OLD_VERSION_NODE function tree to the new version.  */
2199   tree_function_versioning (node->clone_of->decl, node->decl,
2200                             node->clone.tree_map, true,
2201                             node->clone.args_to_skip);
2202   if (cgraph_dump_file)
2203     {
2204       dump_function_to_file (node->clone_of->decl, cgraph_dump_file, dump_flags);
2205       dump_function_to_file (node->decl, cgraph_dump_file, dump_flags);
2206     }
2207
2208   /* Function is no longer clone.  */
2209   if (node->next_sibling_clone)
2210     node->next_sibling_clone->prev_sibling_clone = node->prev_sibling_clone;
2211   if (node->prev_sibling_clone)
2212     node->prev_sibling_clone->next_sibling_clone = node->next_sibling_clone;
2213   else
2214     node->clone_of->clones = node->next_sibling_clone;
2215   node->next_sibling_clone = NULL;
2216   node->prev_sibling_clone = NULL;
2217   if (!node->clone_of->analyzed && !node->clone_of->clones)
2218     cgraph_remove_node (node->clone_of);
2219   node->clone_of = NULL;
2220   bitmap_obstack_release (NULL);
2221 }
2222
2223 /* Once all functions from compilation unit are in memory, produce all clones
2224    and update all calls.
2225    We might also do this on demand if we don't want to bring all functions to
2226    memory prior compilation, but current WHOPR implementation does that and it is
2227    is bit easier to keep everything right in this order.  */
2228 void
2229 cgraph_materialize_all_clones (void)
2230 {
2231   struct cgraph_node *node;
2232   bool stabilized = false;
2233
2234   if (cgraph_dump_file)
2235     fprintf (cgraph_dump_file, "Materializing clones\n");
2236 #ifdef ENABLE_CHECKING
2237   verify_cgraph ();
2238 #endif
2239
2240   /* We can also do topological order, but number of iterations should be
2241      bounded by number of IPA passes since single IPA pass is probably not
2242      going to create clones of clones it created itself.  */
2243   while (!stabilized)
2244     {
2245       stabilized = true;
2246       for (node = cgraph_nodes; node; node = node->next)
2247         {
2248           if (node->clone_of && node->decl != node->clone_of->decl
2249               && !gimple_has_body_p (node->decl))
2250             {
2251               if (gimple_has_body_p (node->clone_of->decl))
2252                 {
2253                   if (cgraph_dump_file)
2254                     {
2255                       fprintf (cgraph_dump_file, "clonning %s to %s\n",
2256                                cgraph_node_name (node->clone_of),
2257                                cgraph_node_name (node));
2258                       if (node->clone.tree_map)
2259                         {
2260                           unsigned int i;
2261                           fprintf (cgraph_dump_file, "   replace map: ");
2262                           for (i = 0; i < VEC_length (ipa_replace_map_p,
2263                                                       node->clone.tree_map);
2264                                                       i++)
2265                             {
2266                               struct ipa_replace_map *replace_info;
2267                               replace_info = VEC_index (ipa_replace_map_p,
2268                                                         node->clone.tree_map,
2269                                                         i);
2270                               print_generic_expr (cgraph_dump_file, replace_info->old_tree, 0);
2271                               fprintf (cgraph_dump_file, " -> ");
2272                               print_generic_expr (cgraph_dump_file, replace_info->new_tree, 0);
2273                               fprintf (cgraph_dump_file, "%s%s;",
2274                                        replace_info->replace_p ? "(replace)":"",
2275                                        replace_info->ref_p ? "(ref)":"");
2276                             }
2277                           fprintf (cgraph_dump_file, "\n");
2278                         }
2279                       if (node->clone.args_to_skip)
2280                         {
2281                           fprintf (cgraph_dump_file, "   args_to_skip: ");
2282                           dump_bitmap (cgraph_dump_file, node->clone.args_to_skip);
2283                         }
2284                       if (node->clone.args_to_skip)
2285                         {
2286                           fprintf (cgraph_dump_file, "   combined_args_to_skip:");
2287                           dump_bitmap (cgraph_dump_file, node->clone.combined_args_to_skip);
2288                         }
2289                     }
2290                   cgraph_materialize_clone (node);
2291                 }
2292               else
2293                 stabilized = false;
2294             }
2295         }
2296     }
2297   for (node = cgraph_nodes; node; node = node->next)
2298     if (!node->analyzed && node->callees)
2299       cgraph_node_remove_callees (node);
2300   if (cgraph_dump_file)
2301     fprintf (cgraph_dump_file, "Updating call sites\n");
2302   for (node = cgraph_nodes; node; node = node->next)
2303     if (node->analyzed && gimple_has_body_p (node->decl)
2304         && (!node->clone_of || node->clone_of->decl != node->decl))
2305       {
2306         struct cgraph_edge *e;
2307
2308         current_function_decl = node->decl;
2309         push_cfun (DECL_STRUCT_FUNCTION (node->decl));
2310         for (e = node->callees; e; e = e->next_callee)
2311           {
2312             tree decl = gimple_call_fndecl (e->call_stmt);
2313             /* When function gets inlined, indirect inlining might've invented
2314                new edge for orginally indirect stmt.  Since we are not
2315                preserving clones in the original form, we must not update here
2316                since other inline clones don't need to contain call to the same
2317                call.  Inliner will do the substitution for us later.  */
2318             if (decl && decl != e->callee->decl)
2319               {
2320                 gimple new_stmt;
2321                 gimple_stmt_iterator gsi;
2322
2323                 if (cgraph_get_node (decl) == cgraph_get_node (e->callee->decl))
2324                   /* Don't update call from same body alias to the real function.  */
2325                   continue;
2326
2327                 if (cgraph_dump_file)
2328                   {
2329                     fprintf (cgraph_dump_file, "updating call of %s in %s:",
2330                              cgraph_node_name (node),
2331                              cgraph_node_name (e->callee));
2332                     print_gimple_stmt (cgraph_dump_file, e->call_stmt, 0, dump_flags);
2333                   }
2334
2335                 if (e->callee->clone.combined_args_to_skip)
2336                   new_stmt = gimple_call_copy_skip_args (e->call_stmt,
2337                                                          e->callee->clone.combined_args_to_skip);
2338                 else
2339                   new_stmt = e->call_stmt;
2340                 if (gimple_vdef (new_stmt)
2341                     && TREE_CODE (gimple_vdef (new_stmt)) == SSA_NAME)
2342                   SSA_NAME_DEF_STMT (gimple_vdef (new_stmt)) = new_stmt;
2343                 gimple_call_set_fndecl (new_stmt, e->callee->decl);
2344
2345                 gsi = gsi_for_stmt (e->call_stmt);
2346                 gsi_replace (&gsi, new_stmt, true);
2347
2348                 /* Update EH information too, just in case.  */
2349                 maybe_clean_or_replace_eh_stmt (e->call_stmt, new_stmt);
2350
2351                 cgraph_set_call_stmt_including_clones (node, e->call_stmt, new_stmt);
2352
2353                 if (cgraph_dump_file)
2354                   {
2355                     fprintf (cgraph_dump_file, "  updated to:");
2356                     print_gimple_stmt (cgraph_dump_file, e->call_stmt, 0, dump_flags);
2357                   }
2358               }
2359           }
2360         pop_cfun ();
2361         current_function_decl = NULL;
2362 #ifdef ENABLE_CHECKING
2363         verify_cgraph_node (node);
2364 #endif
2365       }
2366 #ifdef ENABLE_CHECKING
2367   verify_cgraph ();
2368 #endif
2369   cgraph_remove_unreachable_nodes (false, cgraph_dump_file);
2370 }
2371
2372 #include "gt-cgraphunit.h"