OSDN Git Service

PR middle-end/42228
[pf3gnuchains/gcc-fork.git] / gcc / cgraphunit.c
1 /* Callgraph based interprocedural optimizations.
2    Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
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 (lookup_attribute ("used", DECL_ATTRIBUTES (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 (lookup_attribute ("used", DECL_ATTRIBUTES (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 decl is a clone of an abstract function, mark that abstract
986          function so that we don't release its body. The DECL_INITIAL() of that
987          abstract function declaration will be later needed to output debug info.  */
988       if (DECL_ABSTRACT_ORIGIN (decl))
989         {
990           struct cgraph_node *origin_node = cgraph_node (DECL_ABSTRACT_ORIGIN (decl));
991           origin_node->abstract_and_needed = true;
992         }
993
994       /* We finalize local static variables during constructing callgraph
995          edges.  Process their attributes too.  */
996       process_function_and_variable_attributes (first_processed,
997                                                 first_analyzed_var);
998       first_processed = cgraph_nodes;
999       first_analyzed_var = varpool_nodes;
1000       varpool_analyze_pending_decls ();
1001       cgraph_process_new_functions ();
1002     }
1003
1004   /* Collect entry points to the unit.  */
1005   if (cgraph_dump_file)
1006     {
1007       fprintf (cgraph_dump_file, "Unit entry points:");
1008       for (node = cgraph_nodes; node != first_analyzed; node = node->next)
1009         if (node->needed)
1010           fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
1011       fprintf (cgraph_dump_file, "\n\nInitial ");
1012       dump_cgraph (cgraph_dump_file);
1013     }
1014
1015   if (cgraph_dump_file)
1016     fprintf (cgraph_dump_file, "\nReclaiming functions:");
1017
1018   for (node = cgraph_nodes; node != first_analyzed; node = next)
1019     {
1020       tree decl = node->decl;
1021       next = node->next;
1022
1023       if (node->local.finalized && !gimple_has_body_p (decl))
1024         cgraph_reset_node (node);
1025
1026       if (!node->reachable && gimple_has_body_p (decl))
1027         {
1028           if (cgraph_dump_file)
1029             fprintf (cgraph_dump_file, " %s", cgraph_node_name (node));
1030           cgraph_remove_node (node);
1031           continue;
1032         }
1033       else
1034         node->next_needed = NULL;
1035       gcc_assert (!node->local.finalized || gimple_has_body_p (decl));
1036       gcc_assert (node->analyzed == node->local.finalized);
1037     }
1038   if (cgraph_dump_file)
1039     {
1040       fprintf (cgraph_dump_file, "\n\nReclaimed ");
1041       dump_cgraph (cgraph_dump_file);
1042     }
1043   first_analyzed = cgraph_nodes;
1044   ggc_collect ();
1045 }
1046
1047
1048 /* Analyze the whole compilation unit once it is parsed completely.  */
1049
1050 void
1051 cgraph_finalize_compilation_unit (void)
1052 {
1053   timevar_push (TV_CGRAPH);
1054
1055   /* Do not skip analyzing the functions if there were errors, we
1056      miss diagnostics for following functions otherwise.  */
1057
1058   /* Emit size functions we didn't inline.  */
1059   finalize_size_functions ();
1060
1061   /* Call functions declared with the "constructor" or "destructor"
1062      attribute.  */
1063   cgraph_build_cdtor_fns ();
1064
1065   /* Mark alias targets necessary and emit diagnostics.  */
1066   finish_aliases_1 ();
1067
1068   if (!quiet_flag)
1069     {
1070       fprintf (stderr, "\nAnalyzing compilation unit\n");
1071       fflush (stderr);
1072     }
1073
1074   /* Gimplify and lower all functions, compute reachability and
1075      remove unreachable nodes.  */
1076   cgraph_analyze_functions ();
1077
1078   /* Mark alias targets necessary and emit diagnostics.  */
1079   finish_aliases_1 ();
1080
1081   /* Gimplify and lower thunks.  */
1082   cgraph_analyze_functions ();
1083
1084   /* Finally drive the pass manager.  */
1085   cgraph_optimize ();
1086
1087   timevar_pop (TV_CGRAPH);
1088 }
1089
1090
1091 /* Figure out what functions we want to assemble.  */
1092
1093 static void
1094 cgraph_mark_functions_to_output (void)
1095 {
1096   struct cgraph_node *node;
1097
1098   for (node = cgraph_nodes; node; node = node->next)
1099     {
1100       tree decl = node->decl;
1101       struct cgraph_edge *e;
1102
1103       gcc_assert (!node->process);
1104
1105       for (e = node->callers; e; e = e->next_caller)
1106         if (e->inline_failed)
1107           break;
1108
1109       /* We need to output all local functions that are used and not
1110          always inlined, as well as those that are reachable from
1111          outside the current compilation unit.  */
1112       if (node->analyzed
1113           && !node->global.inlined_to
1114           && (node->needed
1115               || (e && node->reachable))
1116           && !TREE_ASM_WRITTEN (decl)
1117           && !DECL_EXTERNAL (decl))
1118         node->process = 1;
1119       else
1120         {
1121           /* We should've reclaimed all functions that are not needed.  */
1122 #ifdef ENABLE_CHECKING
1123           if (!node->global.inlined_to
1124               && gimple_has_body_p (decl)
1125               && !DECL_EXTERNAL (decl))
1126             {
1127               dump_cgraph_node (stderr, node);
1128               internal_error ("failed to reclaim unneeded function");
1129             }
1130 #endif
1131           gcc_assert (node->global.inlined_to
1132                       || !gimple_has_body_p (decl)
1133                       || DECL_EXTERNAL (decl));
1134
1135         }
1136
1137     }
1138 }
1139
1140 /* DECL is FUNCTION_DECL.  Initialize datastructures so DECL is a function
1141    in lowered gimple form.
1142    
1143    Set current_function_decl and cfun to newly constructed empty function body.
1144    return basic block in the function body.  */
1145
1146 static basic_block
1147 init_lowered_empty_function (tree decl)
1148 {
1149   basic_block bb;
1150
1151   current_function_decl = decl;
1152   allocate_struct_function (decl, false);
1153   gimple_register_cfg_hooks ();
1154   init_empty_tree_cfg ();
1155   init_tree_ssa (cfun);
1156   init_ssa_operands ();
1157   cfun->gimple_df->in_ssa_p = true;
1158   DECL_INITIAL (decl) = make_node (BLOCK);
1159
1160   DECL_SAVED_TREE (decl) = error_mark_node;
1161   cfun->curr_properties |=
1162     (PROP_gimple_lcf | PROP_gimple_leh | PROP_cfg | PROP_referenced_vars |
1163      PROP_ssa);
1164
1165   /* Create BB for body of the function and connect it properly.  */
1166   bb = create_basic_block (NULL, (void *) 0, ENTRY_BLOCK_PTR);
1167   make_edge (ENTRY_BLOCK_PTR, bb, 0);
1168   make_edge (bb, EXIT_BLOCK_PTR, 0);
1169
1170   return bb;
1171 }
1172
1173 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
1174    offset indicated by VIRTUAL_OFFSET, if that is
1175    non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
1176    zero for a result adjusting thunk.  */
1177
1178 static tree
1179 thunk_adjust (gimple_stmt_iterator * bsi,
1180               tree ptr, bool this_adjusting,
1181               HOST_WIDE_INT fixed_offset, tree virtual_offset)
1182 {
1183   gimple stmt;
1184   tree ret;
1185
1186   if (this_adjusting)
1187     {
1188       stmt = gimple_build_assign (ptr,
1189                                   fold_build2_loc (input_location,
1190                                                    POINTER_PLUS_EXPR,
1191                                                    TREE_TYPE (ptr), ptr,
1192                                                    size_int (fixed_offset)));
1193       gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1194     }
1195
1196   /* If there's a virtual offset, look up that value in the vtable and
1197      adjust the pointer again.  */
1198   if (virtual_offset)
1199     {
1200       tree vtabletmp;
1201       tree vtabletmp2;
1202       tree vtabletmp3;
1203       tree offsettmp;
1204
1205       if (!vtable_entry_type)
1206         {
1207           tree vfunc_type = make_node (FUNCTION_TYPE);
1208           TREE_TYPE (vfunc_type) = integer_type_node;
1209           TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
1210           layout_type (vfunc_type);
1211
1212           vtable_entry_type = build_pointer_type (vfunc_type);
1213         }
1214
1215       vtabletmp =
1216         create_tmp_var (build_pointer_type
1217                         (build_pointer_type (vtable_entry_type)), "vptr");
1218
1219       /* The vptr is always at offset zero in the object.  */
1220       stmt = gimple_build_assign (vtabletmp,
1221                                   build1 (NOP_EXPR, TREE_TYPE (vtabletmp),
1222                                           ptr));
1223       gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1224       mark_symbols_for_renaming (stmt);
1225       find_referenced_vars_in (stmt);
1226
1227       /* Form the vtable address.  */
1228       vtabletmp2 = create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp)),
1229                                    "vtableaddr");
1230       stmt = gimple_build_assign (vtabletmp2,
1231                                   build1 (INDIRECT_REF,
1232                                           TREE_TYPE (vtabletmp2), vtabletmp));
1233       gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1234       mark_symbols_for_renaming (stmt);
1235       find_referenced_vars_in (stmt);
1236
1237       /* Find the entry with the vcall offset.  */
1238       stmt = gimple_build_assign (vtabletmp2,
1239                                   fold_build2_loc (input_location,
1240                                                    POINTER_PLUS_EXPR,
1241                                                    TREE_TYPE (vtabletmp2),
1242                                                    vtabletmp2,
1243                                                    fold_convert (sizetype,
1244                                                                  virtual_offset)));
1245       gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1246
1247       /* Get the offset itself.  */
1248       vtabletmp3 = create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp2)),
1249                                    "vcalloffset");
1250       stmt = gimple_build_assign (vtabletmp3,
1251                                   build1 (INDIRECT_REF,
1252                                           TREE_TYPE (vtabletmp3),
1253                                           vtabletmp2));
1254       gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1255       mark_symbols_for_renaming (stmt);
1256       find_referenced_vars_in (stmt);
1257
1258       /* Cast to sizetype.  */
1259       offsettmp = create_tmp_var (sizetype, "offset");
1260       stmt = gimple_build_assign (offsettmp, fold_convert (sizetype, vtabletmp3));
1261       gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1262       mark_symbols_for_renaming (stmt);
1263       find_referenced_vars_in (stmt);
1264
1265       /* Adjust the `this' pointer.  */
1266       ptr = fold_build2_loc (input_location,
1267                              POINTER_PLUS_EXPR, TREE_TYPE (ptr), ptr,
1268                              offsettmp);
1269     }
1270
1271   if (!this_adjusting)
1272     /* Adjust the pointer by the constant.  */
1273     {
1274       tree ptrtmp;
1275
1276       if (TREE_CODE (ptr) == VAR_DECL)
1277         ptrtmp = ptr;
1278       else
1279         {
1280           ptrtmp = create_tmp_var (TREE_TYPE (ptr), "ptr");
1281           stmt = gimple_build_assign (ptrtmp, ptr);
1282           gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1283           mark_symbols_for_renaming (stmt);
1284           find_referenced_vars_in (stmt);
1285         }
1286       ptr = fold_build2_loc (input_location,
1287                              POINTER_PLUS_EXPR, TREE_TYPE (ptrtmp), ptrtmp,
1288                              size_int (fixed_offset));
1289     }
1290
1291   /* Emit the statement and gimplify the adjustment expression.  */
1292   ret = create_tmp_var (TREE_TYPE (ptr), "adjusted_this");
1293   stmt = gimple_build_assign (ret, ptr);
1294   mark_symbols_for_renaming (stmt);
1295   find_referenced_vars_in (stmt);
1296   gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1297
1298   return ret;
1299 }
1300
1301 /* Produce assembler for thunk NODE.  */
1302
1303 static void
1304 assemble_thunk (struct cgraph_node *node)
1305 {
1306   bool this_adjusting = node->thunk.this_adjusting;
1307   HOST_WIDE_INT fixed_offset = node->thunk.fixed_offset;
1308   HOST_WIDE_INT virtual_value = node->thunk.virtual_value;
1309   tree virtual_offset = NULL;
1310   tree alias = node->thunk.alias;
1311   tree thunk_fndecl = node->decl;
1312   tree a = DECL_ARGUMENTS (thunk_fndecl);
1313
1314   current_function_decl = thunk_fndecl;
1315
1316   if (this_adjusting
1317       && targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
1318                                               virtual_value, alias))
1319     {
1320       const char *fnname;
1321       tree fn_block;
1322       
1323       DECL_RESULT (thunk_fndecl)
1324         = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl),
1325                       RESULT_DECL, 0, integer_type_node);
1326       fnname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk_fndecl));
1327
1328       /* The back end expects DECL_INITIAL to contain a BLOCK, so we
1329          create one.  */
1330       fn_block = make_node (BLOCK);
1331       BLOCK_VARS (fn_block) = a;
1332       DECL_INITIAL (thunk_fndecl) = fn_block;
1333       init_function_start (thunk_fndecl);
1334       cfun->is_thunk = 1;
1335       assemble_start_function (thunk_fndecl, fnname);
1336
1337       targetm.asm_out.output_mi_thunk (asm_out_file, thunk_fndecl,
1338                                        fixed_offset, virtual_value, alias);
1339
1340       assemble_end_function (thunk_fndecl, fnname);
1341       init_insn_lengths ();
1342       free_after_compilation (cfun);
1343       set_cfun (NULL);
1344       TREE_ASM_WRITTEN (thunk_fndecl) = 1;
1345     }
1346   else
1347     {
1348       tree restype;
1349       basic_block bb, then_bb, else_bb, return_bb;
1350       gimple_stmt_iterator bsi;
1351       int nargs = 0;
1352       tree arg;
1353       int i;
1354       tree resdecl;
1355       tree restmp = NULL;
1356       VEC(tree, heap) *vargs;
1357
1358       gimple call;
1359       gimple ret;
1360
1361       DECL_IGNORED_P (thunk_fndecl) = 1;
1362       bitmap_obstack_initialize (NULL);
1363
1364       if (node->thunk.virtual_offset_p)
1365         virtual_offset = size_int (virtual_value);
1366
1367       /* Build the return declaration for the function.  */
1368       restype = TREE_TYPE (TREE_TYPE (thunk_fndecl));
1369       if (DECL_RESULT (thunk_fndecl) == NULL_TREE)
1370         {
1371           resdecl = build_decl (input_location, RESULT_DECL, 0, restype);
1372           DECL_ARTIFICIAL (resdecl) = 1;
1373           DECL_IGNORED_P (resdecl) = 1;
1374           DECL_RESULT (thunk_fndecl) = resdecl;
1375         }
1376       else
1377         resdecl = DECL_RESULT (thunk_fndecl);
1378
1379       bb = then_bb = else_bb = return_bb = init_lowered_empty_function (thunk_fndecl);
1380
1381       bsi = gsi_start_bb (bb);
1382
1383       /* Build call to the function being thunked.  */
1384       if (!VOID_TYPE_P (restype))
1385         {
1386           if (!is_gimple_reg_type (restype))
1387             {
1388               restmp = resdecl;
1389               cfun->local_decls = tree_cons (NULL_TREE, restmp, cfun->local_decls);
1390               BLOCK_VARS (DECL_INITIAL (current_function_decl)) = restmp;
1391             }
1392           else
1393             restmp = create_tmp_var_raw (restype, "retval");
1394         }
1395
1396       for (arg = a; arg; arg = TREE_CHAIN (arg))
1397         nargs++;
1398       vargs = VEC_alloc (tree, heap, nargs);
1399       if (this_adjusting)
1400         VEC_quick_push (tree, vargs,
1401                         thunk_adjust (&bsi,
1402                                       a, 1, fixed_offset,
1403                                       virtual_offset));
1404       else
1405         VEC_quick_push (tree, vargs, a);
1406       for (i = 1, arg = TREE_CHAIN (a); i < nargs; i++, arg = TREE_CHAIN (arg))
1407         VEC_quick_push (tree, vargs, arg);
1408       call = gimple_build_call_vec (build_fold_addr_expr_loc (0, alias), vargs);
1409       VEC_free (tree, heap, vargs);
1410       gimple_call_set_cannot_inline (call, true);
1411       gimple_call_set_from_thunk (call, true);
1412       if (restmp)
1413         gimple_call_set_lhs (call, restmp);
1414       gsi_insert_after (&bsi, call, GSI_NEW_STMT);
1415       mark_symbols_for_renaming (call);
1416       find_referenced_vars_in (call);
1417       update_stmt (call);
1418
1419       if (restmp && !this_adjusting)
1420         {
1421           tree true_label = NULL_TREE, false_label = NULL_TREE;
1422
1423           if (TREE_CODE (TREE_TYPE (restmp)) == POINTER_TYPE)
1424             {
1425               gimple stmt;
1426               /* If the return type is a pointer, we need to
1427                  protect against NULL.  We know there will be an
1428                  adjustment, because that's why we're emitting a
1429                  thunk.  */
1430               then_bb = create_basic_block (NULL, (void *) 0, bb);
1431               return_bb = create_basic_block (NULL, (void *) 0, then_bb);
1432               else_bb = create_basic_block (NULL, (void *) 0, else_bb);
1433               remove_edge (single_succ_edge (bb));
1434               true_label = gimple_block_label (then_bb);
1435               false_label = gimple_block_label (else_bb);
1436               stmt = gimple_build_cond (NE_EXPR, restmp,
1437                                         fold_convert (TREE_TYPE (restmp),
1438                                                       integer_zero_node),
1439                                         NULL_TREE, NULL_TREE);
1440               gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
1441               make_edge (bb, then_bb, EDGE_TRUE_VALUE);
1442               make_edge (bb, else_bb, EDGE_FALSE_VALUE);
1443               make_edge (return_bb, EXIT_BLOCK_PTR, 0);
1444               make_edge (then_bb, return_bb, EDGE_FALLTHRU);
1445               make_edge (else_bb, return_bb, EDGE_FALLTHRU);
1446               bsi = gsi_last_bb (then_bb);
1447             }
1448
1449           restmp = thunk_adjust (&bsi, restmp, /*this_adjusting=*/0,
1450                                  fixed_offset, virtual_offset);
1451           if (true_label)
1452             {
1453               gimple stmt;
1454               bsi = gsi_last_bb (else_bb);
1455               stmt = gimple_build_assign (restmp, fold_convert (TREE_TYPE (restmp),
1456                                                                 integer_zero_node));
1457               gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
1458               bsi = gsi_last_bb (return_bb);
1459             }
1460         }
1461       else
1462         gimple_call_set_tail (call, true);
1463
1464       /* Build return value.  */
1465       ret = gimple_build_return (restmp);
1466       gsi_insert_after (&bsi, ret, GSI_NEW_STMT);
1467
1468       delete_unreachable_blocks ();
1469       update_ssa (TODO_update_ssa);
1470
1471       cgraph_remove_same_body_alias (node);
1472       /* Since we want to emit the thunk, we explicitly mark its name as
1473          referenced.  */
1474       mark_decl_referenced (thunk_fndecl);
1475       cgraph_add_new_function (thunk_fndecl, true);
1476       bitmap_obstack_release (NULL);
1477     }
1478   current_function_decl = NULL;
1479 }
1480
1481 /* Expand function specified by NODE.  */
1482
1483 static void
1484 cgraph_expand_function (struct cgraph_node *node)
1485 {
1486   tree decl = node->decl;
1487
1488   /* We ought to not compile any inline clones.  */
1489   gcc_assert (!node->global.inlined_to);
1490
1491   announce_function (decl);
1492   node->process = 0;
1493
1494   gcc_assert (node->lowered);
1495
1496   /* Generate RTL for the body of DECL.  */
1497   tree_rest_of_compilation (decl);
1498
1499   /* Make sure that BE didn't give up on compiling.  */
1500   gcc_assert (TREE_ASM_WRITTEN (decl));
1501   current_function_decl = NULL;
1502   if (node->same_body)
1503     {
1504       struct cgraph_node *alias, *next;
1505       bool saved_alias = node->alias;
1506       for (alias = node->same_body;
1507            alias && alias->next; alias = alias->next)
1508         ;
1509       /* Walk aliases in the order they were created; it is possible that
1510          thunks reffers to the aliases made earlier.  */
1511       for (; alias; alias = next)
1512         {
1513           next = alias->previous;
1514           if (!alias->thunk.thunk_p)
1515             assemble_alias (alias->decl,
1516                             DECL_ASSEMBLER_NAME (alias->thunk.alias));
1517           else
1518             assemble_thunk (alias);
1519         }
1520       node->alias = saved_alias;
1521     }
1522   gcc_assert (!cgraph_preserve_function_body_p (decl));
1523   cgraph_release_function_body (node);
1524   /* Eliminate all call edges.  This is important so the GIMPLE_CALL no longer
1525      points to the dead function body.  */
1526   cgraph_node_remove_callees (node);
1527
1528   cgraph_function_flags_ready = true;
1529 }
1530
1531 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL.  */
1532
1533 bool
1534 cgraph_inline_p (struct cgraph_edge *e, cgraph_inline_failed_t *reason)
1535 {
1536   *reason = e->inline_failed;
1537   return !e->inline_failed;
1538 }
1539
1540
1541
1542 /* Expand all functions that must be output.
1543
1544    Attempt to topologically sort the nodes so function is output when
1545    all called functions are already assembled to allow data to be
1546    propagated across the callgraph.  Use a stack to get smaller distance
1547    between a function and its callees (later we may choose to use a more
1548    sophisticated algorithm for function reordering; we will likely want
1549    to use subsections to make the output functions appear in top-down
1550    order).  */
1551
1552 static void
1553 cgraph_expand_all_functions (void)
1554 {
1555   struct cgraph_node *node;
1556   struct cgraph_node **order = XCNEWVEC (struct cgraph_node *, cgraph_n_nodes);
1557   int order_pos, new_order_pos = 0;
1558   int i;
1559
1560   order_pos = cgraph_postorder (order);
1561   gcc_assert (order_pos == cgraph_n_nodes);
1562
1563   /* Garbage collector may remove inline clones we eliminate during
1564      optimization.  So we must be sure to not reference them.  */
1565   for (i = 0; i < order_pos; i++)
1566     if (order[i]->process)
1567       order[new_order_pos++] = order[i];
1568
1569   for (i = new_order_pos - 1; i >= 0; i--)
1570     {
1571       node = order[i];
1572       if (node->process)
1573         {
1574           gcc_assert (node->reachable);
1575           node->process = 0;
1576           cgraph_expand_function (node);
1577         }
1578     }
1579   cgraph_process_new_functions ();
1580
1581   free (order);
1582
1583 }
1584
1585 /* This is used to sort the node types by the cgraph order number.  */
1586
1587 enum cgraph_order_sort_kind
1588 {
1589   ORDER_UNDEFINED = 0,
1590   ORDER_FUNCTION,
1591   ORDER_VAR,
1592   ORDER_ASM
1593 };
1594
1595 struct cgraph_order_sort
1596 {
1597   enum cgraph_order_sort_kind kind;
1598   union
1599   {
1600     struct cgraph_node *f;
1601     struct varpool_node *v;
1602     struct cgraph_asm_node *a;
1603   } u;
1604 };
1605
1606 /* Output all functions, variables, and asm statements in the order
1607    according to their order fields, which is the order in which they
1608    appeared in the file.  This implements -fno-toplevel-reorder.  In
1609    this mode we may output functions and variables which don't really
1610    need to be output.  */
1611
1612 static void
1613 cgraph_output_in_order (void)
1614 {
1615   int max;
1616   size_t size;
1617   struct cgraph_order_sort *nodes;
1618   int i;
1619   struct cgraph_node *pf;
1620   struct varpool_node *pv;
1621   struct cgraph_asm_node *pa;
1622
1623   max = cgraph_order;
1624   size = max * sizeof (struct cgraph_order_sort);
1625   nodes = (struct cgraph_order_sort *) alloca (size);
1626   memset (nodes, 0, size);
1627
1628   varpool_analyze_pending_decls ();
1629
1630   for (pf = cgraph_nodes; pf; pf = pf->next)
1631     {
1632       if (pf->process)
1633         {
1634           i = pf->order;
1635           gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1636           nodes[i].kind = ORDER_FUNCTION;
1637           nodes[i].u.f = pf;
1638         }
1639     }
1640
1641   for (pv = varpool_nodes_queue; pv; pv = pv->next_needed)
1642     {
1643       i = pv->order;
1644       gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1645       nodes[i].kind = ORDER_VAR;
1646       nodes[i].u.v = pv;
1647     }
1648
1649   for (pa = cgraph_asm_nodes; pa; pa = pa->next)
1650     {
1651       i = pa->order;
1652       gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
1653       nodes[i].kind = ORDER_ASM;
1654       nodes[i].u.a = pa;
1655     }
1656
1657   /* In toplevel reorder mode we output all statics; mark them as needed.  */
1658   for (i = 0; i < max; ++i)
1659     {
1660       if (nodes[i].kind == ORDER_VAR)
1661         {
1662           varpool_mark_needed_node (nodes[i].u.v);
1663         }
1664     }
1665   varpool_empty_needed_queue ();
1666
1667   for (i = 0; i < max; ++i)
1668     {
1669       switch (nodes[i].kind)
1670         {
1671         case ORDER_FUNCTION:
1672           nodes[i].u.f->process = 0;
1673           cgraph_expand_function (nodes[i].u.f);
1674           break;
1675
1676         case ORDER_VAR:
1677           varpool_assemble_decl (nodes[i].u.v);
1678           break;
1679
1680         case ORDER_ASM:
1681           assemble_asm (nodes[i].u.a->asm_str);
1682           break;
1683
1684         case ORDER_UNDEFINED:
1685           break;
1686
1687         default:
1688           gcc_unreachable ();
1689         }
1690     }
1691
1692   cgraph_asm_nodes = NULL;
1693 }
1694
1695 /* Return true when function body of DECL still needs to be kept around
1696    for later re-use.  */
1697 bool
1698 cgraph_preserve_function_body_p (tree decl)
1699 {
1700   struct cgraph_node *node;
1701
1702   gcc_assert (cgraph_global_info_ready);
1703   /* Look if there is any clone around.  */
1704   node = cgraph_node (decl);
1705   if (node->clones)
1706     return true;
1707   return false;
1708 }
1709
1710 static void
1711 ipa_passes (void)
1712 {
1713   set_cfun (NULL);
1714   current_function_decl = NULL;
1715   gimple_register_cfg_hooks ();
1716   bitmap_obstack_initialize (NULL);
1717
1718   invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_START, NULL);
1719
1720   if (!in_lto_p)
1721     execute_ipa_pass_list (all_small_ipa_passes);
1722
1723   /* If pass_all_early_optimizations was not scheduled, the state of
1724      the cgraph will not be properly updated.  Update it now.  */
1725   if (cgraph_state < CGRAPH_STATE_IPA_SSA)
1726     cgraph_state = CGRAPH_STATE_IPA_SSA;
1727
1728   if (!in_lto_p)
1729     {
1730       /* Generate coverage variables and constructors.  */
1731       coverage_finish ();
1732
1733       /* Process new functions added.  */
1734       set_cfun (NULL);
1735       current_function_decl = NULL;
1736       cgraph_process_new_functions ();
1737
1738       execute_ipa_summary_passes
1739         ((struct ipa_opt_pass_d *) all_regular_ipa_passes);
1740     }
1741   execute_ipa_summary_passes ((struct ipa_opt_pass_d *) all_lto_gen_passes);
1742
1743   if (!in_lto_p)
1744     ipa_write_summaries ();
1745
1746   if (!flag_ltrans)
1747     execute_ipa_pass_list (all_regular_ipa_passes);
1748   invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_END, NULL);
1749
1750   bitmap_obstack_release (NULL);
1751 }
1752
1753
1754 /* Perform simple optimizations based on callgraph.  */
1755
1756 void
1757 cgraph_optimize (void)
1758 {
1759   if (errorcount || sorrycount)
1760     return;
1761
1762 #ifdef ENABLE_CHECKING
1763   verify_cgraph ();
1764 #endif
1765
1766   /* Frontend may output common variables after the unit has been finalized.
1767      It is safe to deal with them here as they are always zero initialized.  */
1768   varpool_analyze_pending_decls ();
1769
1770   timevar_push (TV_CGRAPHOPT);
1771   if (pre_ipa_mem_report)
1772     {
1773       fprintf (stderr, "Memory consumption before IPA\n");
1774       dump_memory_report (false);
1775     }
1776   if (!quiet_flag)
1777     fprintf (stderr, "Performing interprocedural optimizations\n");
1778   cgraph_state = CGRAPH_STATE_IPA;
1779
1780   /* Don't run the IPA passes if there was any error or sorry messages.  */
1781   if (errorcount == 0 && sorrycount == 0)
1782     ipa_passes ();
1783
1784   /* Do nothing else if any IPA pass found errors.  */
1785   if (errorcount || sorrycount)
1786     {
1787       timevar_pop (TV_CGRAPHOPT);
1788       return;
1789     }
1790
1791   /* This pass remove bodies of extern inline functions we never inlined.
1792      Do this later so other IPA passes see what is really going on.  */
1793   cgraph_remove_unreachable_nodes (false, dump_file);
1794   cgraph_global_info_ready = true;
1795   if (cgraph_dump_file)
1796     {
1797       fprintf (cgraph_dump_file, "Optimized ");
1798       dump_cgraph (cgraph_dump_file);
1799       dump_varpool (cgraph_dump_file);
1800     }
1801   if (post_ipa_mem_report)
1802     {
1803       fprintf (stderr, "Memory consumption after IPA\n");
1804       dump_memory_report (false);
1805     }
1806   timevar_pop (TV_CGRAPHOPT);
1807
1808   /* Output everything.  */
1809   (*debug_hooks->assembly_start) ();
1810   if (!quiet_flag)
1811     fprintf (stderr, "Assembling functions:\n");
1812 #ifdef ENABLE_CHECKING
1813   verify_cgraph ();
1814 #endif
1815
1816   cgraph_materialize_all_clones ();
1817   cgraph_mark_functions_to_output ();
1818
1819   cgraph_state = CGRAPH_STATE_EXPANSION;
1820   if (!flag_toplevel_reorder)
1821     cgraph_output_in_order ();
1822   else
1823     {
1824       cgraph_output_pending_asms ();
1825
1826       cgraph_expand_all_functions ();
1827       varpool_remove_unreferenced_decls ();
1828
1829       varpool_assemble_pending_decls ();
1830     }
1831   cgraph_process_new_functions ();
1832   cgraph_state = CGRAPH_STATE_FINISHED;
1833
1834   if (cgraph_dump_file)
1835     {
1836       fprintf (cgraph_dump_file, "\nFinal ");
1837       dump_cgraph (cgraph_dump_file);
1838     }
1839 #ifdef ENABLE_CHECKING
1840   verify_cgraph ();
1841   /* Double check that all inline clones are gone and that all
1842      function bodies have been released from memory.  */
1843   if (!(sorrycount || errorcount))
1844     {
1845       struct cgraph_node *node;
1846       bool error_found = false;
1847
1848       for (node = cgraph_nodes; node; node = node->next)
1849         if (node->analyzed
1850             && (node->global.inlined_to
1851                 || gimple_has_body_p (node->decl)))
1852           {
1853             error_found = true;
1854             dump_cgraph_node (stderr, node);
1855           }
1856       if (error_found)
1857         internal_error ("nodes with unreleased memory found");
1858     }
1859 #endif
1860 }
1861
1862
1863 /* Generate and emit a static constructor or destructor.  WHICH must
1864    be one of 'I' (for a constructor) or 'D' (for a destructor).  BODY
1865    is a STATEMENT_LIST containing GENERIC statements.  PRIORITY is the
1866    initialization priority for this constructor or destructor.  */
1867
1868 void
1869 cgraph_build_static_cdtor (char which, tree body, int priority)
1870 {
1871   static int counter = 0;
1872   char which_buf[16];
1873   tree decl, name, resdecl;
1874
1875   /* The priority is encoded in the constructor or destructor name.
1876      collect2 will sort the names and arrange that they are called at
1877      program startup.  */
1878   sprintf (which_buf, "%c_%.5d_%d", which, priority, counter++);
1879   name = get_file_function_name (which_buf);
1880
1881   decl = build_decl (input_location, FUNCTION_DECL, name,
1882                      build_function_type (void_type_node, void_list_node));
1883   current_function_decl = decl;
1884
1885   resdecl = build_decl (input_location,
1886                         RESULT_DECL, NULL_TREE, void_type_node);
1887   DECL_ARTIFICIAL (resdecl) = 1;
1888   DECL_RESULT (decl) = resdecl;
1889   DECL_CONTEXT (resdecl) = decl;
1890
1891   allocate_struct_function (decl, false);
1892
1893   TREE_STATIC (decl) = 1;
1894   TREE_USED (decl) = 1;
1895   DECL_ARTIFICIAL (decl) = 1;
1896   DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
1897   DECL_SAVED_TREE (decl) = body;
1898   TREE_PUBLIC (decl) = ! targetm.have_ctors_dtors;
1899   DECL_UNINLINABLE (decl) = 1;
1900
1901   DECL_INITIAL (decl) = make_node (BLOCK);
1902   TREE_USED (DECL_INITIAL (decl)) = 1;
1903
1904   DECL_SOURCE_LOCATION (decl) = input_location;
1905   cfun->function_end_locus = input_location;
1906
1907   switch (which)
1908     {
1909     case 'I':
1910       DECL_STATIC_CONSTRUCTOR (decl) = 1;
1911       decl_init_priority_insert (decl, priority);
1912       break;
1913     case 'D':
1914       DECL_STATIC_DESTRUCTOR (decl) = 1;
1915       decl_fini_priority_insert (decl, priority);
1916       break;
1917     default:
1918       gcc_unreachable ();
1919     }
1920
1921   gimplify_function_tree (decl);
1922
1923   cgraph_add_new_function (decl, false);
1924   cgraph_mark_needed_node (cgraph_node (decl));
1925   set_cfun (NULL);
1926 }
1927
1928 void
1929 init_cgraph (void)
1930 {
1931   cgraph_dump_file = dump_begin (TDI_cgraph, NULL);
1932 }
1933
1934 /* The edges representing the callers of the NEW_VERSION node were
1935    fixed by cgraph_function_versioning (), now the call_expr in their
1936    respective tree code should be updated to call the NEW_VERSION.  */
1937
1938 static void
1939 update_call_expr (struct cgraph_node *new_version)
1940 {
1941   struct cgraph_edge *e;
1942
1943   gcc_assert (new_version);
1944
1945   /* Update the call expr on the edges to call the new version.  */
1946   for (e = new_version->callers; e; e = e->next_caller)
1947     {
1948       struct function *inner_function = DECL_STRUCT_FUNCTION (e->caller->decl);
1949       gimple_call_set_fndecl (e->call_stmt, new_version->decl);
1950       maybe_clean_eh_stmt_fn (inner_function, e->call_stmt);
1951     }
1952 }
1953
1954
1955 /* Create a new cgraph node which is the new version of
1956    OLD_VERSION node.  REDIRECT_CALLERS holds the callers
1957    edges which should be redirected to point to
1958    NEW_VERSION.  ALL the callees edges of OLD_VERSION
1959    are cloned to the new version node.  Return the new
1960    version node.  */
1961
1962 static struct cgraph_node *
1963 cgraph_copy_node_for_versioning (struct cgraph_node *old_version,
1964                                  tree new_decl,
1965                                  VEC(cgraph_edge_p,heap) *redirect_callers)
1966  {
1967    struct cgraph_node *new_version;
1968    struct cgraph_edge *e, *new_e;
1969    struct cgraph_edge *next_callee;
1970    unsigned i;
1971
1972    gcc_assert (old_version);
1973
1974    new_version = cgraph_node (new_decl);
1975
1976    new_version->analyzed = true;
1977    new_version->local = old_version->local;
1978    new_version->global = old_version->global;
1979    new_version->rtl = new_version->rtl;
1980    new_version->reachable = true;
1981    new_version->count = old_version->count;
1982
1983    /* Clone the old node callees.  Recursive calls are
1984       also cloned.  */
1985    for (e = old_version->callees;e; e=e->next_callee)
1986      {
1987        new_e = cgraph_clone_edge (e, new_version, e->call_stmt,
1988                                   e->lto_stmt_uid, 0, e->frequency,
1989                                   e->loop_nest, true);
1990        new_e->count = e->count;
1991      }
1992    /* Fix recursive calls.
1993       If OLD_VERSION has a recursive call after the
1994       previous edge cloning, the new version will have an edge
1995       pointing to the old version, which is wrong;
1996       Redirect it to point to the new version. */
1997    for (e = new_version->callees ; e; e = next_callee)
1998      {
1999        next_callee = e->next_callee;
2000        if (e->callee == old_version)
2001          cgraph_redirect_edge_callee (e, new_version);
2002
2003        if (!next_callee)
2004          break;
2005      }
2006    for (i = 0; VEC_iterate (cgraph_edge_p, redirect_callers, i, e); i++)
2007      {
2008        /* Redirect calls to the old version node to point to its new
2009           version.  */
2010        cgraph_redirect_edge_callee (e, new_version);
2011      }
2012
2013    return new_version;
2014  }
2015
2016  /* Perform function versioning.
2017     Function versioning includes copying of the tree and
2018     a callgraph update (creating a new cgraph node and updating
2019     its callees and callers).
2020
2021     REDIRECT_CALLERS varray includes the edges to be redirected
2022     to the new version.
2023
2024     TREE_MAP is a mapping of tree nodes we want to replace with
2025     new ones (according to results of prior analysis).
2026     OLD_VERSION_NODE is the node that is versioned.
2027     It returns the new version's cgraph node.
2028     ARGS_TO_SKIP lists arguments to be omitted from functions
2029     */
2030
2031 struct cgraph_node *
2032 cgraph_function_versioning (struct cgraph_node *old_version_node,
2033                             VEC(cgraph_edge_p,heap) *redirect_callers,
2034                             VEC (ipa_replace_map_p,gc)* tree_map,
2035                             bitmap args_to_skip)
2036 {
2037   tree old_decl = old_version_node->decl;
2038   struct cgraph_node *new_version_node = NULL;
2039   tree new_decl;
2040
2041   if (!tree_versionable_function_p (old_decl))
2042     return NULL;
2043
2044   /* Make a new FUNCTION_DECL tree node for the
2045      new version. */
2046   if (!args_to_skip)
2047     new_decl = copy_node (old_decl);
2048   else
2049     new_decl = build_function_decl_skip_args (old_decl, args_to_skip);
2050
2051   /* Create the new version's call-graph node.
2052      and update the edges of the new node. */
2053   new_version_node =
2054     cgraph_copy_node_for_versioning (old_version_node, new_decl,
2055                                      redirect_callers);
2056
2057   /* Copy the OLD_VERSION_NODE function tree to the new version.  */
2058   tree_function_versioning (old_decl, new_decl, tree_map, false, args_to_skip);
2059
2060   /* Update the new version's properties.
2061      Make The new version visible only within this translation unit.  Make sure
2062      that is not weak also.
2063      ??? We cannot use COMDAT linkage because there is no
2064      ABI support for this.  */
2065   DECL_EXTERNAL (new_version_node->decl) = 0;
2066   DECL_COMDAT_GROUP (new_version_node->decl) = NULL_TREE;
2067   TREE_PUBLIC (new_version_node->decl) = 0;
2068   DECL_COMDAT (new_version_node->decl) = 0;
2069   DECL_WEAK (new_version_node->decl) = 0;
2070   DECL_VIRTUAL_P (new_version_node->decl) = 0;
2071   new_version_node->local.externally_visible = 0;
2072   new_version_node->local.local = 1;
2073   new_version_node->lowered = true;
2074
2075   /* Update the call_expr on the edges to call the new version node. */
2076   update_call_expr (new_version_node);
2077
2078   cgraph_call_function_insertion_hooks (new_version_node);
2079   return new_version_node;
2080 }
2081
2082 /* Produce separate function body for inline clones so the offline copy can be
2083    modified without affecting them.  */
2084 struct cgraph_node *
2085 save_inline_function_body (struct cgraph_node *node)
2086 {
2087   struct cgraph_node *first_clone, *n;
2088
2089   gcc_assert (node == cgraph_node (node->decl));
2090
2091   cgraph_lower_function (node);
2092
2093   first_clone = node->clones;
2094
2095   first_clone->decl = copy_node (node->decl);
2096   cgraph_insert_node_to_hashtable (first_clone);
2097   gcc_assert (first_clone == cgraph_node (first_clone->decl));
2098   if (first_clone->next_sibling_clone)
2099     {
2100       for (n = first_clone->next_sibling_clone; n->next_sibling_clone; n = n->next_sibling_clone)
2101         n->clone_of = first_clone;
2102       n->clone_of = first_clone;
2103       n->next_sibling_clone = first_clone->clones;
2104       if (first_clone->clones)
2105         first_clone->clones->prev_sibling_clone = n;
2106       first_clone->clones = first_clone->next_sibling_clone;
2107       first_clone->next_sibling_clone->prev_sibling_clone = NULL;
2108       first_clone->next_sibling_clone = NULL;
2109       gcc_assert (!first_clone->prev_sibling_clone);
2110     }
2111   first_clone->clone_of = NULL;
2112   node->clones = NULL;
2113
2114   if (first_clone->clones)
2115     for (n = first_clone->clones; n != first_clone;)
2116       {
2117         gcc_assert (n->decl == node->decl);
2118         n->decl = first_clone->decl;
2119         if (n->clones)
2120           n = n->clones;
2121         else if (n->next_sibling_clone)
2122           n = n->next_sibling_clone;
2123         else
2124           {
2125             while (n != first_clone && !n->next_sibling_clone)
2126               n = n->clone_of;
2127             if (n != first_clone)
2128               n = n->next_sibling_clone;
2129           }
2130       }
2131
2132   /* Copy the OLD_VERSION_NODE function tree to the new version.  */
2133   tree_function_versioning (node->decl, first_clone->decl, NULL, true, NULL);
2134
2135   DECL_EXTERNAL (first_clone->decl) = 0;
2136   DECL_COMDAT_GROUP (first_clone->decl) = NULL_TREE;
2137   TREE_PUBLIC (first_clone->decl) = 0;
2138   DECL_COMDAT (first_clone->decl) = 0;
2139   VEC_free (ipa_opt_pass, heap,
2140             first_clone->ipa_transforms_to_apply);
2141   first_clone->ipa_transforms_to_apply = NULL;
2142
2143 #ifdef ENABLE_CHECKING
2144   verify_cgraph_node (first_clone);
2145 #endif
2146   return first_clone;
2147 }
2148
2149 /* Given virtual clone, turn it into actual clone.  */
2150 static void
2151 cgraph_materialize_clone (struct cgraph_node *node)
2152 {
2153   bitmap_obstack_initialize (NULL);
2154   /* Copy the OLD_VERSION_NODE function tree to the new version.  */
2155   tree_function_versioning (node->clone_of->decl, node->decl,
2156                             node->clone.tree_map, true,
2157                             node->clone.args_to_skip);
2158   if (cgraph_dump_file)
2159     {
2160       dump_function_to_file (node->clone_of->decl, cgraph_dump_file, dump_flags);
2161       dump_function_to_file (node->decl, cgraph_dump_file, dump_flags);
2162     }
2163
2164   /* Function is no longer clone.  */
2165   if (node->next_sibling_clone)
2166     node->next_sibling_clone->prev_sibling_clone = node->prev_sibling_clone;
2167   if (node->prev_sibling_clone)
2168     node->prev_sibling_clone->next_sibling_clone = node->next_sibling_clone;
2169   else
2170     node->clone_of->clones = node->next_sibling_clone;
2171   node->next_sibling_clone = NULL;
2172   node->prev_sibling_clone = NULL;
2173   if (!node->clone_of->analyzed && !node->clone_of->clones)
2174     cgraph_remove_node (node->clone_of);
2175   node->clone_of = NULL;
2176   bitmap_obstack_release (NULL);
2177 }
2178
2179 /* Once all functions from compilation unit are in memory, produce all clones
2180    and update all calls.
2181    We might also do this on demand if we don't want to bring all functions to
2182    memory prior compilation, but current WHOPR implementation does that and it is
2183    is bit easier to keep everything right in this order.  */
2184 void
2185 cgraph_materialize_all_clones (void)
2186 {
2187   struct cgraph_node *node;
2188   bool stabilized = false;
2189
2190   if (cgraph_dump_file)
2191     fprintf (cgraph_dump_file, "Materializing clones\n");
2192 #ifdef ENABLE_CHECKING
2193   verify_cgraph ();
2194 #endif
2195
2196   /* We can also do topological order, but number of iterations should be
2197      bounded by number of IPA passes since single IPA pass is probably not
2198      going to create clones of clones it created itself.  */
2199   while (!stabilized)
2200     {
2201       stabilized = true;
2202       for (node = cgraph_nodes; node; node = node->next)
2203         {
2204           if (node->clone_of && node->decl != node->clone_of->decl
2205               && !gimple_has_body_p (node->decl))
2206             {
2207               if (gimple_has_body_p (node->clone_of->decl))
2208                 {
2209                   if (cgraph_dump_file)
2210                     {
2211                       fprintf (cgraph_dump_file, "clonning %s to %s\n",
2212                                cgraph_node_name (node->clone_of),
2213                                cgraph_node_name (node));
2214                       if (node->clone.tree_map)
2215                         {
2216                           unsigned int i;
2217                           fprintf (cgraph_dump_file, "   replace map: ");
2218                           for (i = 0; i < VEC_length (ipa_replace_map_p,
2219                                                       node->clone.tree_map);
2220                                                       i++)
2221                             {
2222                               struct ipa_replace_map *replace_info;
2223                               replace_info = VEC_index (ipa_replace_map_p,
2224                                                         node->clone.tree_map,
2225                                                         i);
2226                               print_generic_expr (cgraph_dump_file, replace_info->old_tree, 0);
2227                               fprintf (cgraph_dump_file, " -> ");
2228                               print_generic_expr (cgraph_dump_file, replace_info->new_tree, 0);
2229                               fprintf (cgraph_dump_file, "%s%s;",
2230                                        replace_info->replace_p ? "(replace)":"",
2231                                        replace_info->ref_p ? "(ref)":"");
2232                             }
2233                           fprintf (cgraph_dump_file, "\n");
2234                         }
2235                       if (node->clone.args_to_skip)
2236                         {
2237                           fprintf (cgraph_dump_file, "   args_to_skip: ");
2238                           dump_bitmap (cgraph_dump_file, node->clone.args_to_skip);
2239                         }
2240                       if (node->clone.args_to_skip)
2241                         {
2242                           fprintf (cgraph_dump_file, "   combined_args_to_skip:");
2243                           dump_bitmap (cgraph_dump_file, node->clone.combined_args_to_skip);
2244                         }
2245                     }
2246                   cgraph_materialize_clone (node);
2247                 }
2248               else
2249                 stabilized = false;
2250             }
2251         }
2252     }
2253   for (node = cgraph_nodes; node; node = node->next)
2254     if (!node->analyzed && node->callees)
2255       cgraph_node_remove_callees (node);
2256   if (cgraph_dump_file)
2257     fprintf (cgraph_dump_file, "Updating call sites\n");
2258   for (node = cgraph_nodes; node; node = node->next)
2259     if (node->analyzed && gimple_has_body_p (node->decl)
2260         && (!node->clone_of || node->clone_of->decl != node->decl))
2261       {
2262         struct cgraph_edge *e;
2263
2264         current_function_decl = node->decl;
2265         push_cfun (DECL_STRUCT_FUNCTION (node->decl));
2266         for (e = node->callees; e; e = e->next_callee)
2267           {
2268             tree decl = gimple_call_fndecl (e->call_stmt);
2269             /* When function gets inlined, indirect inlining might've invented
2270                new edge for orginally indirect stmt.  Since we are not
2271                preserving clones in the original form, we must not update here
2272                since other inline clones don't need to contain call to the same
2273                call.  Inliner will do the substitution for us later.  */
2274             if (decl && decl != e->callee->decl)
2275               {
2276                 gimple new_stmt;
2277                 gimple_stmt_iterator gsi;
2278
2279                 if (e->callee->same_body)
2280                   {
2281                     struct cgraph_node *alias;
2282
2283                     for (alias = e->callee->same_body;
2284                          alias;
2285                          alias = alias->next)
2286                       if (decl == alias->decl)
2287                         break;
2288                     /* Don't update call from same body alias to the real
2289                        function.  */
2290                     if (alias)
2291                       continue;
2292                   }
2293
2294                 if (cgraph_dump_file)
2295                   {
2296                     fprintf (cgraph_dump_file, "updating call of %s in %s:",
2297                              cgraph_node_name (node),
2298                              cgraph_node_name (e->callee));
2299                     print_gimple_stmt (cgraph_dump_file, e->call_stmt, 0, dump_flags);
2300                   }
2301
2302                 if (e->callee->clone.combined_args_to_skip)
2303                   new_stmt = gimple_call_copy_skip_args (e->call_stmt,
2304                                                          e->callee->clone.combined_args_to_skip);
2305                 else
2306                   new_stmt = e->call_stmt;
2307                 if (gimple_vdef (new_stmt)
2308                     && TREE_CODE (gimple_vdef (new_stmt)) == SSA_NAME)
2309                   SSA_NAME_DEF_STMT (gimple_vdef (new_stmt)) = new_stmt;
2310                 gimple_call_set_fndecl (new_stmt, e->callee->decl);
2311
2312                 gsi = gsi_for_stmt (e->call_stmt);
2313                 gsi_replace (&gsi, new_stmt, true);
2314
2315                 /* Update EH information too, just in case.  */
2316                 maybe_clean_or_replace_eh_stmt (e->call_stmt, new_stmt);
2317
2318                 cgraph_set_call_stmt_including_clones (node, e->call_stmt, new_stmt);
2319
2320                 if (cgraph_dump_file)
2321                   {
2322                     fprintf (cgraph_dump_file, "  updated to:");
2323                     print_gimple_stmt (cgraph_dump_file, e->call_stmt, 0, dump_flags);
2324                   }
2325               }
2326           }
2327         pop_cfun ();
2328         current_function_decl = NULL;
2329 #ifdef ENABLE_CHECKING
2330         verify_cgraph_node (node);
2331 #endif
2332       }
2333 #ifdef ENABLE_CHECKING
2334   verify_cgraph ();
2335 #endif
2336   cgraph_remove_unreachable_nodes (false, cgraph_dump_file);
2337 }
2338
2339 #include "gt-cgraphunit.h"