Update gcc-50 to SVN version 221423
[dragonfly.git] / contrib / gcc-5.0 / gcc / cgraphunit.c
CommitLineData
dda118e3
JM
1/* Driver of optimization process
2 Copyright (C) 2003-2015 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 3, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING3. If not see
19<http://www.gnu.org/licenses/>. */
20
21/* This module implements main driver of compilation process.
22
23 The main scope of this file is to act as an interface in between
24 tree based frontends and the backend.
25
26 The front-end is supposed to use following functionality:
27
28 - finalize_function
29
30 This function is called once front-end has parsed whole body of function
31 and it is certain that the function body nor the declaration will change.
32
33 (There is one exception needed for implementing GCC extern inline
34 function.)
35
36 - varpool_finalize_decl
37
38 This function has same behavior as the above but is used for static
39 variables.
40
41 - add_asm_node
42
43 Insert new toplevel ASM statement
44
45 - finalize_compilation_unit
46
47 This function is called once (source level) compilation unit is finalized
48 and it will no longer change.
49
50 The symbol table is constructed starting from the trivially needed
51 symbols finalized by the frontend. Functions are lowered into
52 GIMPLE representation and callgraph/reference lists are constructed.
53 Those are used to discover other necessary functions and variables.
54
55 At the end the bodies of unreachable functions are removed.
56
57 The function can be called multiple times when multiple source level
58 compilation units are combined.
59
60 - compile
61
62 This passes control to the back-end. Optimizations are performed and
63 final assembler is generated. This is done in the following way. Note
64 that with link time optimization the process is split into three
65 stages (compile time, linktime analysis and parallel linktime as
66 indicated bellow).
67
68 Compile time:
69
70 1) Inter-procedural optimization.
71 (ipa_passes)
72
73 This part is further split into:
74
75 a) early optimizations. These are local passes executed in
76 the topological order on the callgraph.
77
78 The purpose of early optimiations is to optimize away simple
79 things that may otherwise confuse IP analysis. Very simple
80 propagation across the callgraph is done i.e. to discover
81 functions without side effects and simple inlining is performed.
82
83 b) early small interprocedural passes.
84
85 Those are interprocedural passes executed only at compilation
86 time. These include, for example, transational memory lowering,
87 unreachable code removal and other simple transformations.
88
89 c) IP analysis stage. All interprocedural passes do their
90 analysis.
91
92 Interprocedural passes differ from small interprocedural
93 passes by their ability to operate across whole program
94 at linktime. Their analysis stage is performed early to
95 both reduce linking times and linktime memory usage by
96 not having to represent whole program in memory.
97
98 d) LTO sreaming. When doing LTO, everything important gets
99 streamed into the object file.
100
101 Compile time and or linktime analysis stage (WPA):
102
103 At linktime units gets streamed back and symbol table is
104 merged. Function bodies are not streamed in and not
105 available.
106 e) IP propagation stage. All IP passes execute their
107 IP propagation. This is done based on the earlier analysis
108 without having function bodies at hand.
109 f) Ltrans streaming. When doing WHOPR LTO, the program
110 is partitioned and streamed into multple object files.
111
112 Compile time and/or parallel linktime stage (ltrans)
113
114 Each of the object files is streamed back and compiled
115 separately. Now the function bodies becomes available
116 again.
117
118 2) Virtual clone materialization
119 (cgraph_materialize_clone)
120
121 IP passes can produce copies of existing functoins (such
122 as versioned clones or inline clones) without actually
123 manipulating their bodies by creating virtual clones in
124 the callgraph. At this time the virtual clones are
125 turned into real functions
126 3) IP transformation
127
128 All IP passes transform function bodies based on earlier
129 decision of the IP propagation.
130
131 4) late small IP passes
132
133 Simple IP passes working within single program partition.
134
135 5) Expansion
136 (expand_all_functions)
137
138 At this stage functions that needs to be output into
139 assembler are identified and compiled in topological order
140 6) Output of variables and aliases
141 Now it is known what variable references was not optimized
142 out and thus all variables are output to the file.
143
144 Note that with -fno-toplevel-reorder passes 5 and 6
145 are combined together in cgraph_output_in_order.
146
147 Finally there are functions to manipulate the callgraph from
148 backend.
149 - cgraph_add_new_function is used to add backend produced
150 functions introduced after the unit is finalized.
151 The functions are enqueue for later processing and inserted
152 into callgraph with cgraph_process_new_functions.
153
154 - cgraph_function_versioning
155
156 produces a copy of function into new one (a version)
157 and apply simple transformations
158*/
159
160#include "config.h"
161#include "system.h"
162#include "coretypes.h"
163#include "tm.h"
164#include "hash-set.h"
165#include "machmode.h"
166#include "vec.h"
167#include "double-int.h"
168#include "input.h"
169#include "alias.h"
170#include "symtab.h"
171#include "wide-int.h"
172#include "inchash.h"
173#include "tree.h"
174#include "fold-const.h"
175#include "varasm.h"
176#include "stor-layout.h"
177#include "stringpool.h"
178#include "output.h"
179#include "rtl.h"
180#include "predict.h"
181#include "hard-reg-set.h"
182#include "input.h"
183#include "function.h"
184#include "basic-block.h"
185#include "tree-ssa-alias.h"
186#include "internal-fn.h"
187#include "gimple-fold.h"
188#include "gimple-expr.h"
189#include "is-a.h"
190#include "gimple.h"
191#include "gimplify.h"
192#include "gimple-iterator.h"
193#include "gimplify-me.h"
194#include "gimple-ssa.h"
195#include "tree-cfg.h"
196#include "tree-into-ssa.h"
197#include "tree-ssa.h"
198#include "tree-inline.h"
199#include "langhooks.h"
200#include "toplev.h"
201#include "flags.h"
202#include "debug.h"
203#include "target.h"
204#include "diagnostic.h"
205#include "params.h"
206#include "intl.h"
207#include "hash-map.h"
208#include "plugin-api.h"
209#include "ipa-ref.h"
210#include "cgraph.h"
211#include "alloc-pool.h"
212#include "symbol-summary.h"
213#include "ipa-prop.h"
214#include "tree-iterator.h"
215#include "tree-pass.h"
216#include "tree-dump.h"
217#include "gimple-pretty-print.h"
218#include "output.h"
219#include "coverage.h"
220#include "plugin.h"
221#include "ipa-inline.h"
222#include "ipa-utils.h"
223#include "lto-streamer.h"
224#include "except.h"
225#include "cfgloop.h"
226#include "regset.h" /* FIXME: For reg_obstack. */
227#include "context.h"
228#include "pass_manager.h"
229#include "tree-nested.h"
230#include "gimplify.h"
231#include "dbgcnt.h"
232#include "tree-chkp.h"
233#include "lto-section-names.h"
234#include "omp-low.h"
235#include "print-tree.h"
236
237/* Queue of cgraph nodes scheduled to be added into cgraph. This is a
238 secondary queue used during optimization to accommodate passes that
239 may generate new functions that need to be optimized and expanded. */
240vec<cgraph_node *> cgraph_new_nodes;
241
242static void expand_all_functions (void);
243static void mark_functions_to_output (void);
244static void handle_alias_pairs (void);
245
246/* Used for vtable lookup in thunk adjusting. */
247static GTY (()) tree vtable_entry_type;
248
249/* Determine if symbol declaration is needed. That is, visible to something
250 either outside this translation unit, something magic in the system
251 configury */
252bool
253symtab_node::needed_p (void)
254{
255 /* Double check that no one output the function into assembly file
256 early. */
257 gcc_checking_assert (!DECL_ASSEMBLER_NAME_SET_P (decl)
258 || !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)));
259
260 if (!definition)
261 return false;
262
263 if (DECL_EXTERNAL (decl))
264 return false;
265
266 /* If the user told us it is used, then it must be so. */
267 if (force_output)
268 return true;
269
270 /* ABI forced symbols are needed when they are external. */
271 if (forced_by_abi && TREE_PUBLIC (decl))
272 return true;
273
274 /* Keep constructors, destructors and virtual functions. */
275 if (TREE_CODE (decl) == FUNCTION_DECL
276 && (DECL_STATIC_CONSTRUCTOR (decl) || DECL_STATIC_DESTRUCTOR (decl)))
277 return true;
278
279 /* Externally visible variables must be output. The exception is
280 COMDAT variables that must be output only when they are needed. */
281 if (TREE_PUBLIC (decl) && !DECL_COMDAT (decl))
282 return true;
283
284 return false;
285}
286
287/* Head and terminator of the queue of nodes to be processed while building
288 callgraph. */
289
290static symtab_node symtab_terminator;
291static symtab_node *queued_nodes = &symtab_terminator;
292
293/* Add NODE to queue starting at QUEUED_NODES.
294 The queue is linked via AUX pointers and terminated by pointer to 1. */
295
296static void
297enqueue_node (symtab_node *node)
298{
299 if (node->aux)
300 return;
301 gcc_checking_assert (queued_nodes);
302 node->aux = queued_nodes;
303 queued_nodes = node;
304}
305
306/* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these
307 functions into callgraph in a way so they look like ordinary reachable
308 functions inserted into callgraph already at construction time. */
309
310void
311symbol_table::process_new_functions (void)
312{
313 tree fndecl;
314
315 if (!cgraph_new_nodes.exists ())
316 return;
317
318 handle_alias_pairs ();
319 /* Note that this queue may grow as its being processed, as the new
320 functions may generate new ones. */
321 for (unsigned i = 0; i < cgraph_new_nodes.length (); i++)
322 {
323 cgraph_node *node = cgraph_new_nodes[i];
324 fndecl = node->decl;
325 switch (state)
326 {
327 case CONSTRUCTION:
328 /* At construction time we just need to finalize function and move
329 it into reachable functions list. */
330
331 cgraph_node::finalize_function (fndecl, false);
332 call_cgraph_insertion_hooks (node);
333 enqueue_node (node);
334 break;
335
336 case IPA:
337 case IPA_SSA:
338 case IPA_SSA_AFTER_INLINING:
339 /* When IPA optimization already started, do all essential
340 transformations that has been already performed on the whole
341 cgraph but not on this function. */
342
343 gimple_register_cfg_hooks ();
344 if (!node->analyzed)
345 node->analyze ();
346 push_cfun (DECL_STRUCT_FUNCTION (fndecl));
347 if ((state == IPA_SSA || state == IPA_SSA_AFTER_INLINING)
348 && !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl)))
349 g->get_passes ()->execute_early_local_passes ();
350 else if (inline_summaries != NULL)
351 compute_inline_parameters (node, true);
352 free_dominance_info (CDI_POST_DOMINATORS);
353 free_dominance_info (CDI_DOMINATORS);
354 pop_cfun ();
355 call_cgraph_insertion_hooks (node);
356 break;
357
358 case EXPANSION:
359 /* Functions created during expansion shall be compiled
360 directly. */
361 node->process = 0;
362 call_cgraph_insertion_hooks (node);
363 node->expand ();
364 break;
365
366 default:
367 gcc_unreachable ();
368 break;
369 }
370 }
371
372 cgraph_new_nodes.release ();
373}
374
375/* As an GCC extension we allow redefinition of the function. The
376 semantics when both copies of bodies differ is not well defined.
377 We replace the old body with new body so in unit at a time mode
378 we always use new body, while in normal mode we may end up with
379 old body inlined into some functions and new body expanded and
380 inlined in others.
381
382 ??? It may make more sense to use one body for inlining and other
383 body for expanding the function but this is difficult to do. */
384
385void
386cgraph_node::reset (void)
387{
388 /* If process is set, then we have already begun whole-unit analysis.
389 This is *not* testing for whether we've already emitted the function.
390 That case can be sort-of legitimately seen with real function redefinition
391 errors. I would argue that the front end should never present us with
392 such a case, but don't enforce that for now. */
393 gcc_assert (!process);
394
395 /* Reset our data structures so we can analyze the function again. */
396 memset (&local, 0, sizeof (local));
397 memset (&global, 0, sizeof (global));
398 memset (&rtl, 0, sizeof (rtl));
399 analyzed = false;
400 definition = false;
401 alias = false;
402 weakref = false;
403 cpp_implicit_alias = false;
404
405 remove_callees ();
406 remove_all_references ();
407}
408
409/* Return true when there are references to the node. */
410
411bool
412symtab_node::referred_to_p (void)
413{
414 ipa_ref *ref = NULL;
415
416 /* See if there are any references at all. */
417 if (iterate_referring (0, ref))
418 return true;
419 /* For functions check also calls. */
420 cgraph_node *cn = dyn_cast <cgraph_node *> (this);
421 if (cn && cn->callers)
422 return true;
423 return false;
424}
425
426/* DECL has been parsed. Take it, queue it, compile it at the whim of the
427 logic in effect. If NO_COLLECT is true, then our caller cannot stand to have
428 the garbage collector run at the moment. We would need to either create
429 a new GC context, or just not compile right now. */
430
431void
432cgraph_node::finalize_function (tree decl, bool no_collect)
433{
434 cgraph_node *node = cgraph_node::get_create (decl);
435
436 if (node->definition)
437 {
438 /* Nested functions should only be defined once. */
439 gcc_assert (!DECL_CONTEXT (decl)
440 || TREE_CODE (DECL_CONTEXT (decl)) != FUNCTION_DECL);
441 node->reset ();
442 node->local.redefined_extern_inline = true;
443 }
444
9f50539d
JM
445 /* Set definition first before calling notice_global_symbol so that
446 it is available to notice_global_symbol. */
dda118e3 447 node->definition = true;
9f50539d 448 notice_global_symbol (decl);
dda118e3
JM
449 node->lowered = DECL_STRUCT_FUNCTION (decl)->cfg != NULL;
450
451 /* With -fkeep-inline-functions we are keeping all inline functions except
452 for extern inline ones. */
453 if (flag_keep_inline_functions
454 && DECL_DECLARED_INLINE_P (decl)
455 && !DECL_EXTERNAL (decl)
456 && !DECL_DISREGARD_INLINE_LIMITS (decl))
457 node->force_output = 1;
458
459 /* When not optimizing, also output the static functions. (see
460 PR24561), but don't do so for always_inline functions, functions
461 declared inline and nested functions. These were optimized out
462 in the original implementation and it is unclear whether we want
463 to change the behavior here. */
464 if ((!opt_for_fn (decl, optimize)
465 && !node->cpp_implicit_alias
466 && !DECL_DISREGARD_INLINE_LIMITS (decl)
467 && !DECL_DECLARED_INLINE_P (decl)
468 && !(DECL_CONTEXT (decl)
469 && TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL))
470 && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl))
471 node->force_output = 1;
472
473 /* If we've not yet emitted decl, tell the debug info about it. */
474 if (!TREE_ASM_WRITTEN (decl))
475 (*debug_hooks->deferred_inline_function) (decl);
476
477 /* Possibly warn about unused parameters. */
478 if (warn_unused_parameter)
479 do_warn_unused_parameter (decl);
480
481 if (!no_collect)
482 ggc_collect ();
483
484 if (symtab->state == CONSTRUCTION
485 && (node->needed_p () || node->referred_to_p ()))
486 enqueue_node (node);
487}
488
489/* Add the function FNDECL to the call graph.
490 Unlike finalize_function, this function is intended to be used
491 by middle end and allows insertion of new function at arbitrary point
492 of compilation. The function can be either in high, low or SSA form
493 GIMPLE.
494
495 The function is assumed to be reachable and have address taken (so no
496 API breaking optimizations are performed on it).
497
498 Main work done by this function is to enqueue the function for later
499 processing to avoid need the passes to be re-entrant. */
500
501void
502cgraph_node::add_new_function (tree fndecl, bool lowered)
503{
504 gcc::pass_manager *passes = g->get_passes ();
505 cgraph_node *node;
506 switch (symtab->state)
507 {
508 case PARSING:
509 cgraph_node::finalize_function (fndecl, false);
510 break;
511 case CONSTRUCTION:
512 /* Just enqueue function to be processed at nearest occurrence. */
513 node = cgraph_node::get_create (fndecl);
514 if (lowered)
515 node->lowered = true;
516 cgraph_new_nodes.safe_push (node);
517 break;
518
519 case IPA:
520 case IPA_SSA:
521 case IPA_SSA_AFTER_INLINING:
522 case EXPANSION:
523 /* Bring the function into finalized state and enqueue for later
524 analyzing and compilation. */
525 node = cgraph_node::get_create (fndecl);
526 node->local.local = false;
527 node->definition = true;
528 node->force_output = true;
529 if (!lowered && symtab->state == EXPANSION)
530 {
531 push_cfun (DECL_STRUCT_FUNCTION (fndecl));
532 gimple_register_cfg_hooks ();
533 bitmap_obstack_initialize (NULL);
534 execute_pass_list (cfun, passes->all_lowering_passes);
535 passes->execute_early_local_passes ();
536 bitmap_obstack_release (NULL);
537 pop_cfun ();
538
539 lowered = true;
540 }
541 if (lowered)
542 node->lowered = true;
543 cgraph_new_nodes.safe_push (node);
544 break;
545
546 case FINISHED:
547 /* At the very end of compilation we have to do all the work up
548 to expansion. */
549 node = cgraph_node::create (fndecl);
550 if (lowered)
551 node->lowered = true;
552 node->definition = true;
553 node->analyze ();
554 push_cfun (DECL_STRUCT_FUNCTION (fndecl));
555 gimple_register_cfg_hooks ();
556 bitmap_obstack_initialize (NULL);
557 if (!gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl)))
558 g->get_passes ()->execute_early_local_passes ();
559 bitmap_obstack_release (NULL);
560 pop_cfun ();
561 node->expand ();
562 break;
563
564 default:
565 gcc_unreachable ();
566 }
567
568 /* Set a personality if required and we already passed EH lowering. */
569 if (lowered
570 && (function_needs_eh_personality (DECL_STRUCT_FUNCTION (fndecl))
571 == eh_personality_lang))
572 DECL_FUNCTION_PERSONALITY (fndecl) = lang_hooks.eh_personality ();
573}
574
575/* Analyze the function scheduled to be output. */
576void
577cgraph_node::analyze (void)
578{
579 tree decl = this->decl;
580 location_t saved_loc = input_location;
581 input_location = DECL_SOURCE_LOCATION (decl);
582
583 if (thunk.thunk_p)
584 {
9f50539d
JM
585 cgraph_node *t = cgraph_node::get (thunk.alias);
586
587 create_edge (t, NULL, 0, CGRAPH_FREQ_BASE);
588 /* Target code in expand_thunk may need the thunk's target
589 to be analyzed, so recurse here. */
590 if (!t->analyzed)
591 t->analyze ();
592 if (t->alias)
593 {
594 t = t->get_alias_target ();
595 if (!t->analyzed)
596 t->analyze ();
597 }
dda118e3
JM
598 if (!expand_thunk (false, false))
599 {
600 thunk.alias = NULL;
601 return;
602 }
603 thunk.alias = NULL;
604 }
605 if (alias)
606 resolve_alias (cgraph_node::get (alias_target));
607 else if (dispatcher_function)
608 {
609 /* Generate the dispatcher body of multi-versioned functions. */
610 cgraph_function_version_info *dispatcher_version_info
611 = function_version ();
612 if (dispatcher_version_info != NULL
613 && (dispatcher_version_info->dispatcher_resolver
614 == NULL_TREE))
615 {
616 tree resolver = NULL_TREE;
617 gcc_assert (targetm.generate_version_dispatcher_body);
618 resolver = targetm.generate_version_dispatcher_body (this);
619 gcc_assert (resolver != NULL_TREE);
620 }
621 }
622 else
623 {
624 push_cfun (DECL_STRUCT_FUNCTION (decl));
625
626 assign_assembler_name_if_neeeded (decl);
627
628 /* Make sure to gimplify bodies only once. During analyzing a
629 function we lower it, which will require gimplified nested
630 functions, so we can end up here with an already gimplified
631 body. */
632 if (!gimple_has_body_p (decl))
633 gimplify_function_tree (decl);
634 dump_function (TDI_generic, decl);
635
636 /* Lower the function. */
637 if (!lowered)
638 {
639 if (nested)
640 lower_nested_functions (decl);
641 gcc_assert (!nested);
642
643 gimple_register_cfg_hooks ();
644 bitmap_obstack_initialize (NULL);
645 execute_pass_list (cfun, g->get_passes ()->all_lowering_passes);
646 free_dominance_info (CDI_POST_DOMINATORS);
647 free_dominance_info (CDI_DOMINATORS);
648 compact_blocks ();
649 bitmap_obstack_release (NULL);
650 lowered = true;
651 }
652
653 pop_cfun ();
654 }
655 analyzed = true;
656
657 input_location = saved_loc;
658}
659
660/* C++ frontend produce same body aliases all over the place, even before PCH
661 gets streamed out. It relies on us linking the aliases with their function
662 in order to do the fixups, but ipa-ref is not PCH safe. Consequentely we
663 first produce aliases without links, but once C++ FE is sure he won't sream
664 PCH we build the links via this function. */
665
666void
667symbol_table::process_same_body_aliases (void)
668{
669 symtab_node *node;
670 FOR_EACH_SYMBOL (node)
671 if (node->cpp_implicit_alias && !node->analyzed)
672 node->resolve_alias
673 (TREE_CODE (node->alias_target) == VAR_DECL
674 ? (symtab_node *)varpool_node::get_create (node->alias_target)
675 : (symtab_node *)cgraph_node::get_create (node->alias_target));
676 cpp_implicit_aliases_done = true;
677}
678
679/* Process attributes common for vars and functions. */
680
681static void
682process_common_attributes (symtab_node *node, tree decl)
683{
684 tree weakref = lookup_attribute ("weakref", DECL_ATTRIBUTES (decl));
685
686 if (weakref && !lookup_attribute ("alias", DECL_ATTRIBUTES (decl)))
687 {
688 warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wattributes,
689 "%<weakref%> attribute should be accompanied with"
690 " an %<alias%> attribute");
691 DECL_WEAK (decl) = 0;
692 DECL_ATTRIBUTES (decl) = remove_attribute ("weakref",
693 DECL_ATTRIBUTES (decl));
694 }
695
696 if (lookup_attribute ("no_reorder", DECL_ATTRIBUTES (decl)))
697 node->no_reorder = 1;
698}
699
700/* Look for externally_visible and used attributes and mark cgraph nodes
701 accordingly.
702
703 We cannot mark the nodes at the point the attributes are processed (in
704 handle_*_attribute) because the copy of the declarations available at that
705 point may not be canonical. For example, in:
706
707 void f();
708 void f() __attribute__((used));
709
710 the declaration we see in handle_used_attribute will be the second
711 declaration -- but the front end will subsequently merge that declaration
712 with the original declaration and discard the second declaration.
713
714 Furthermore, we can't mark these nodes in finalize_function because:
715
716 void f() {}
717 void f() __attribute__((externally_visible));
718
719 is valid.
720
721 So, we walk the nodes at the end of the translation unit, applying the
722 attributes at that point. */
723
724static void
725process_function_and_variable_attributes (cgraph_node *first,
726 varpool_node *first_var)
727{
728 cgraph_node *node;
729 varpool_node *vnode;
730
731 for (node = symtab->first_function (); node != first;
732 node = symtab->next_function (node))
733 {
734 tree decl = node->decl;
735 if (DECL_PRESERVE_P (decl))
736 node->mark_force_output ();
737 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl)))
738 {
739 if (! TREE_PUBLIC (node->decl))
740 warning_at (DECL_SOURCE_LOCATION (node->decl), OPT_Wattributes,
741 "%<externally_visible%>"
742 " attribute have effect only on public objects");
743 }
744 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))
745 && (node->definition && !node->alias))
746 {
747 warning_at (DECL_SOURCE_LOCATION (node->decl), OPT_Wattributes,
748 "%<weakref%> attribute ignored"
749 " because function is defined");
750 DECL_WEAK (decl) = 0;
751 DECL_ATTRIBUTES (decl) = remove_attribute ("weakref",
752 DECL_ATTRIBUTES (decl));
753 }
754
755 if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (decl))
756 && !DECL_DECLARED_INLINE_P (decl)
757 /* redefining extern inline function makes it DECL_UNINLINABLE. */
758 && !DECL_UNINLINABLE (decl))
759 warning_at (DECL_SOURCE_LOCATION (decl), OPT_Wattributes,
760 "always_inline function might not be inlinable");
761
762 process_common_attributes (node, decl);
763 }
764 for (vnode = symtab->first_variable (); vnode != first_var;
765 vnode = symtab->next_variable (vnode))
766 {
767 tree decl = vnode->decl;
768 if (DECL_EXTERNAL (decl)
769 && DECL_INITIAL (decl))
770 varpool_node::finalize_decl (decl);
771 if (DECL_PRESERVE_P (decl))
772 vnode->force_output = true;
773 else if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl)))
774 {
775 if (! TREE_PUBLIC (vnode->decl))
776 warning_at (DECL_SOURCE_LOCATION (vnode->decl), OPT_Wattributes,
777 "%<externally_visible%>"
778 " attribute have effect only on public objects");
779 }
780 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl))
781 && vnode->definition
782 && DECL_INITIAL (decl))
783 {
784 warning_at (DECL_SOURCE_LOCATION (vnode->decl), OPT_Wattributes,
785 "%<weakref%> attribute ignored"
786 " because variable is initialized");
787 DECL_WEAK (decl) = 0;
788 DECL_ATTRIBUTES (decl) = remove_attribute ("weakref",
789 DECL_ATTRIBUTES (decl));
790 }
791 process_common_attributes (vnode, decl);
792 }
793}
794
795/* Mark DECL as finalized. By finalizing the declaration, frontend instruct the
796 middle end to output the variable to asm file, if needed or externally
797 visible. */
798
799void
800varpool_node::finalize_decl (tree decl)
801{
802 varpool_node *node = varpool_node::get_create (decl);
803
804 gcc_assert (TREE_STATIC (decl) || DECL_EXTERNAL (decl));
805
806 if (node->definition)
807 return;
9f50539d
JM
808 /* Set definition first before calling notice_global_symbol so that
809 it is available to notice_global_symbol. */
dda118e3 810 node->definition = true;
9f50539d 811 notice_global_symbol (decl);
dda118e3
JM
812 if (TREE_THIS_VOLATILE (decl) || DECL_PRESERVE_P (decl)
813 /* Traditionally we do not eliminate static variables when not
814 optimizing and when not doing toplevel reoder. */
815 || node->no_reorder
816 || ((!flag_toplevel_reorder
817 && !DECL_COMDAT (node->decl)
818 && !DECL_ARTIFICIAL (node->decl))))
819 node->force_output = true;
820
821 if (symtab->state == CONSTRUCTION
822 && (node->needed_p () || node->referred_to_p ()))
823 enqueue_node (node);
824 if (symtab->state >= IPA_SSA)
825 node->analyze ();
826 /* Some frontends produce various interface variables after compilation
827 finished. */
828 if (symtab->state == FINISHED
829 || (!flag_toplevel_reorder
830 && symtab->state == EXPANSION))
831 node->assemble_decl ();
832
833 if (DECL_INITIAL (decl))
834 chkp_register_var_initializer (decl);
835}
836
837/* EDGE is an polymorphic call. Mark all possible targets as reachable
838 and if there is only one target, perform trivial devirtualization.
839 REACHABLE_CALL_TARGETS collects target lists we already walked to
840 avoid udplicate work. */
841
842static void
843walk_polymorphic_call_targets (hash_set<void *> *reachable_call_targets,
844 cgraph_edge *edge)
845{
846 unsigned int i;
847 void *cache_token;
848 bool final;
849 vec <cgraph_node *>targets
850 = possible_polymorphic_call_targets
851 (edge, &final, &cache_token);
852
853 if (!reachable_call_targets->add (cache_token))
854 {
855 if (symtab->dump_file)
856 dump_possible_polymorphic_call_targets
857 (symtab->dump_file, edge);
858
859 for (i = 0; i < targets.length (); i++)
860 {
861 /* Do not bother to mark virtual methods in anonymous namespace;
862 either we will find use of virtual table defining it, or it is
863 unused. */
864 if (targets[i]->definition
865 && TREE_CODE
866 (TREE_TYPE (targets[i]->decl))
867 == METHOD_TYPE
868 && !type_in_anonymous_namespace_p
869 (method_class_type
870 (TREE_TYPE (targets[i]->decl))))
871 enqueue_node (targets[i]);
872 }
873 }
874
875 /* Very trivial devirtualization; when the type is
876 final or anonymous (so we know all its derivation)
877 and there is only one possible virtual call target,
878 make the edge direct. */
879 if (final)
880 {
881 if (targets.length () <= 1 && dbg_cnt (devirt))
882 {
883 cgraph_node *target;
884 if (targets.length () == 1)
885 target = targets[0];
886 else
887 target = cgraph_node::create
888 (builtin_decl_implicit (BUILT_IN_UNREACHABLE));
889
890 if (symtab->dump_file)
891 {
892 fprintf (symtab->dump_file,
893 "Devirtualizing call: ");
894 print_gimple_stmt (symtab->dump_file,
895 edge->call_stmt, 0,
896 TDF_SLIM);
897 }
898 if (dump_enabled_p ())
899 {
900 location_t locus = gimple_location_safe (edge->call_stmt);
901 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, locus,
902 "devirtualizing call in %s to %s\n",
903 edge->caller->name (), target->name ());
904 }
905
906 edge->make_direct (target);
907 edge->redirect_call_stmt_to_callee ();
908
909 /* Call to __builtin_unreachable shouldn't be instrumented. */
910 if (!targets.length ())
911 gimple_call_set_with_bounds (edge->call_stmt, false);
912
913 if (symtab->dump_file)
914 {
915 fprintf (symtab->dump_file,
916 "Devirtualized as: ");
917 print_gimple_stmt (symtab->dump_file,
918 edge->call_stmt, 0,
919 TDF_SLIM);
920 }
921 }
922 }
923}
924
925
926/* Discover all functions and variables that are trivially needed, analyze
927 them as well as all functions and variables referred by them */
928static cgraph_node *first_analyzed;
929static varpool_node *first_analyzed_var;
930
931static void
932analyze_functions (void)
933{
934 /* Keep track of already processed nodes when called multiple times for
935 intermodule optimization. */
936 cgraph_node *first_handled = first_analyzed;
937 varpool_node *first_handled_var = first_analyzed_var;
938 hash_set<void *> reachable_call_targets;
939
940 symtab_node *node;
941 symtab_node *next;
942 int i;
943 ipa_ref *ref;
944 bool changed = true;
945 location_t saved_loc = input_location;
946
947 bitmap_obstack_initialize (NULL);
948 symtab->state = CONSTRUCTION;
949 input_location = UNKNOWN_LOCATION;
950
951 /* Ugly, but the fixup can not happen at a time same body alias is created;
952 C++ FE is confused about the COMDAT groups being right. */
953 if (symtab->cpp_implicit_aliases_done)
954 FOR_EACH_SYMBOL (node)
955 if (node->cpp_implicit_alias)
956 node->fixup_same_cpp_alias_visibility (node->get_alias_target ());
957 build_type_inheritance_graph ();
958
959 /* Analysis adds static variables that in turn adds references to new functions.
960 So we need to iterate the process until it stabilize. */
961 while (changed)
962 {
963 changed = false;
964 process_function_and_variable_attributes (first_analyzed,
965 first_analyzed_var);
966
967 /* First identify the trivially needed symbols. */
968 for (node = symtab->first_symbol ();
969 node != first_analyzed
970 && node != first_analyzed_var; node = node->next)
971 {
972 /* Convert COMDAT group designators to IDENTIFIER_NODEs. */
973 node->get_comdat_group_id ();
974 if (node->needed_p ())
975 {
976 enqueue_node (node);
977 if (!changed && symtab->dump_file)
978 fprintf (symtab->dump_file, "Trivially needed symbols:");
979 changed = true;
980 if (symtab->dump_file)
981 fprintf (symtab->dump_file, " %s", node->asm_name ());
982 if (!changed && symtab->dump_file)
983 fprintf (symtab->dump_file, "\n");
984 }
985 if (node == first_analyzed
986 || node == first_analyzed_var)
987 break;
988 }
989 symtab->process_new_functions ();
990 first_analyzed_var = symtab->first_variable ();
991 first_analyzed = symtab->first_function ();
992
993 if (changed && symtab->dump_file)
994 fprintf (symtab->dump_file, "\n");
995
996 /* Lower representation, build callgraph edges and references for all trivially
997 needed symbols and all symbols referred by them. */
998 while (queued_nodes != &symtab_terminator)
999 {
1000 changed = true;
1001 node = queued_nodes;
1002 queued_nodes = (symtab_node *)queued_nodes->aux;
1003 cgraph_node *cnode = dyn_cast <cgraph_node *> (node);
1004 if (cnode && cnode->definition)
1005 {
1006 cgraph_edge *edge;
1007 tree decl = cnode->decl;
1008
1009 /* ??? It is possible to create extern inline function
1010 and later using weak alias attribute to kill its body.
1011 See gcc.c-torture/compile/20011119-1.c */
1012 if (!DECL_STRUCT_FUNCTION (decl)
1013 && !cnode->alias
1014 && !cnode->thunk.thunk_p
1015 && !cnode->dispatcher_function)
1016 {
1017 cnode->reset ();
1018 cnode->local.redefined_extern_inline = true;
1019 continue;
1020 }
1021
1022 if (!cnode->analyzed)
1023 cnode->analyze ();
1024
1025 for (edge = cnode->callees; edge; edge = edge->next_callee)
1026 if (edge->callee->definition
1027 && (!DECL_EXTERNAL (edge->callee->decl)
1028 /* When not optimizing, do not try to analyze extern
1029 inline functions. Doing so is pointless. */
1030 || opt_for_fn (edge->callee->decl, optimize)
1031 /* Weakrefs needs to be preserved. */
1032 || edge->callee->alias
1033 /* always_inline functions are inlined aven at -O0. */
1034 || lookup_attribute
1035 ("always_inline",
1036 DECL_ATTRIBUTES (edge->callee->decl))
1037 /* Multiversioned functions needs the dispatcher to
1038 be produced locally even for extern functions. */
1039 || edge->callee->function_version ()))
1040 enqueue_node (edge->callee);
1041 if (opt_for_fn (cnode->decl, optimize)
1042 && opt_for_fn (cnode->decl, flag_devirtualize))
1043 {
1044 cgraph_edge *next;
1045
1046 for (edge = cnode->indirect_calls; edge; edge = next)
1047 {
1048 next = edge->next_callee;
1049 if (edge->indirect_info->polymorphic)
1050 walk_polymorphic_call_targets (&reachable_call_targets,
1051 edge);
1052 }
1053 }
1054
1055 /* If decl is a clone of an abstract function,
1056 mark that abstract function so that we don't release its body.
1057 The DECL_INITIAL() of that abstract function declaration
1058 will be later needed to output debug info. */
1059 if (DECL_ABSTRACT_ORIGIN (decl))
1060 {
1061 cgraph_node *origin_node
1062 = cgraph_node::get_create (DECL_ABSTRACT_ORIGIN (decl));
1063 origin_node->used_as_abstract_origin = true;
1064 }
1065 }
1066 else
1067 {
1068 varpool_node *vnode = dyn_cast <varpool_node *> (node);
1069 if (vnode && vnode->definition && !vnode->analyzed)
1070 vnode->analyze ();
1071 }
1072
1073 if (node->same_comdat_group)
1074 {
1075 symtab_node *next;
1076 for (next = node->same_comdat_group;
1077 next != node;
1078 next = next->same_comdat_group)
1079 if (!next->comdat_local_p ())
1080 enqueue_node (next);
1081 }
1082 for (i = 0; node->iterate_reference (i, ref); i++)
1083 if (ref->referred->definition
1084 && (!DECL_EXTERNAL (ref->referred->decl)
1085 || ((TREE_CODE (ref->referred->decl) != FUNCTION_DECL
1086 && optimize)
1087 || (TREE_CODE (ref->referred->decl) == FUNCTION_DECL
1088 && opt_for_fn (ref->referred->decl, optimize))
1089 || node->alias
1090 || ref->referred->alias)))
1091 enqueue_node (ref->referred);
1092 symtab->process_new_functions ();
1093 }
1094 }
1095 update_type_inheritance_graph ();
1096
1097 /* Collect entry points to the unit. */
1098 if (symtab->dump_file)
1099 {
1100 fprintf (symtab->dump_file, "\n\nInitial ");
1101 symtab_node::dump_table (symtab->dump_file);
1102 }
1103
1104 if (symtab->dump_file)
1105 fprintf (symtab->dump_file, "\nRemoving unused symbols:");
1106
1107 for (node = symtab->first_symbol ();
1108 node != first_handled
1109 && node != first_handled_var; node = next)
1110 {
1111 next = node->next;
1112 if (!node->aux && !node->referred_to_p ())
1113 {
1114 if (symtab->dump_file)
1115 fprintf (symtab->dump_file, " %s", node->name ());
1116 node->remove ();
1117 continue;
1118 }
1119 if (cgraph_node *cnode = dyn_cast <cgraph_node *> (node))
1120 {
1121 tree decl = node->decl;
1122
1123 if (cnode->definition && !gimple_has_body_p (decl)
1124 && !cnode->alias
1125 && !cnode->thunk.thunk_p)
1126 cnode->reset ();
1127
1128 gcc_assert (!cnode->definition || cnode->thunk.thunk_p
1129 || cnode->alias
1130 || gimple_has_body_p (decl));
1131 gcc_assert (cnode->analyzed == cnode->definition);
1132 }
1133 node->aux = NULL;
1134 }
1135 for (;node; node = node->next)
1136 node->aux = NULL;
1137 first_analyzed = symtab->first_function ();
1138 first_analyzed_var = symtab->first_variable ();
1139 if (symtab->dump_file)
1140 {
1141 fprintf (symtab->dump_file, "\n\nReclaimed ");
1142 symtab_node::dump_table (symtab->dump_file);
1143 }
1144 bitmap_obstack_release (NULL);
1145 ggc_collect ();
1146 /* Initialize assembler name hash, in particular we want to trigger C++
1147 mangling and same body alias creation before we free DECL_ARGUMENTS
1148 used by it. */
1149 if (!seen_error ())
1150 symtab->symtab_initialize_asm_name_hash ();
1151
1152 input_location = saved_loc;
1153}
1154
1155/* Translate the ugly representation of aliases as alias pairs into nice
1156 representation in callgraph. We don't handle all cases yet,
1157 unfortunately. */
1158
1159static void
1160handle_alias_pairs (void)
1161{
1162 alias_pair *p;
1163 unsigned i;
1164
1165 for (i = 0; alias_pairs && alias_pairs->iterate (i, &p);)
1166 {
1167 symtab_node *target_node = symtab_node::get_for_asmname (p->target);
1168
1169 /* Weakrefs with target not defined in current unit are easy to handle:
1170 they behave just as external variables except we need to note the
1171 alias flag to later output the weakref pseudo op into asm file. */
1172 if (!target_node
1173 && lookup_attribute ("weakref", DECL_ATTRIBUTES (p->decl)) != NULL)
1174 {
1175 symtab_node *node = symtab_node::get (p->decl);
1176 if (node)
1177 {
1178 node->alias_target = p->target;
1179 node->weakref = true;
1180 node->alias = true;
1181 }
1182 alias_pairs->unordered_remove (i);
1183 continue;
1184 }
1185 else if (!target_node)
1186 {
1187 error ("%q+D aliased to undefined symbol %qE", p->decl, p->target);
1188 symtab_node *node = symtab_node::get (p->decl);
1189 if (node)
1190 node->alias = false;
1191 alias_pairs->unordered_remove (i);
1192 continue;
1193 }
1194
1195 if (DECL_EXTERNAL (target_node->decl)
1196 /* We use local aliases for C++ thunks to force the tailcall
1197 to bind locally. This is a hack - to keep it working do
1198 the following (which is not strictly correct). */
1199 && (TREE_CODE (target_node->decl) != FUNCTION_DECL
1200 || ! DECL_VIRTUAL_P (target_node->decl))
1201 && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (p->decl)))
1202 {
1203 error ("%q+D aliased to external symbol %qE",
1204 p->decl, p->target);
1205 }
1206
1207 if (TREE_CODE (p->decl) == FUNCTION_DECL
1208 && target_node && is_a <cgraph_node *> (target_node))
1209 {
1210 cgraph_node *src_node = cgraph_node::get (p->decl);
1211 if (src_node && src_node->definition)
1212 src_node->reset ();
1213 cgraph_node::create_alias (p->decl, target_node->decl);
1214 alias_pairs->unordered_remove (i);
1215 }
1216 else if (TREE_CODE (p->decl) == VAR_DECL
1217 && target_node && is_a <varpool_node *> (target_node))
1218 {
1219 varpool_node::create_alias (p->decl, target_node->decl);
1220 alias_pairs->unordered_remove (i);
1221 }
1222 else
1223 {
1224 error ("%q+D alias in between function and variable is not supported",
1225 p->decl);
1226 warning (0, "%q+D aliased declaration",
1227 target_node->decl);
1228 alias_pairs->unordered_remove (i);
1229 }
1230 }
1231 vec_free (alias_pairs);
1232}
1233
1234
1235/* Figure out what functions we want to assemble. */
1236
1237static void
1238mark_functions_to_output (void)
1239{
1240 cgraph_node *node;
1241#ifdef ENABLE_CHECKING
1242 bool check_same_comdat_groups = false;
1243
1244 FOR_EACH_FUNCTION (node)
1245 gcc_assert (!node->process);
1246#endif
1247
1248 FOR_EACH_FUNCTION (node)
1249 {
1250 tree decl = node->decl;
1251
1252 gcc_assert (!node->process || node->same_comdat_group);
1253 if (node->process)
1254 continue;
1255
1256 /* We need to output all local functions that are used and not
1257 always inlined, as well as those that are reachable from
1258 outside the current compilation unit. */
1259 if (node->analyzed
1260 && !node->thunk.thunk_p
1261 && !node->alias
1262 && !node->global.inlined_to
1263 && !TREE_ASM_WRITTEN (decl)
1264 && !DECL_EXTERNAL (decl))
1265 {
1266 node->process = 1;
1267 if (node->same_comdat_group)
1268 {
1269 cgraph_node *next;
1270 for (next = dyn_cast<cgraph_node *> (node->same_comdat_group);
1271 next != node;
1272 next = dyn_cast<cgraph_node *> (next->same_comdat_group))
1273 if (!next->thunk.thunk_p && !next->alias
1274 && !next->comdat_local_p ())
1275 next->process = 1;
1276 }
1277 }
1278 else if (node->same_comdat_group)
1279 {
1280#ifdef ENABLE_CHECKING
1281 check_same_comdat_groups = true;
1282#endif
1283 }
1284 else
1285 {
1286 /* We should've reclaimed all functions that are not needed. */
1287#ifdef ENABLE_CHECKING
1288 if (!node->global.inlined_to
1289 && gimple_has_body_p (decl)
1290 /* FIXME: in ltrans unit when offline copy is outside partition but inline copies
1291 are inside partition, we can end up not removing the body since we no longer
1292 have analyzed node pointing to it. */
1293 && !node->in_other_partition
1294 && !node->alias
1295 && !node->clones
1296 && !DECL_EXTERNAL (decl))
1297 {
1298 node->debug ();
1299 internal_error ("failed to reclaim unneeded function");
1300 }
1301#endif
1302 gcc_assert (node->global.inlined_to
1303 || !gimple_has_body_p (decl)
1304 || node->in_other_partition
1305 || node->clones
1306 || DECL_ARTIFICIAL (decl)
1307 || DECL_EXTERNAL (decl));
1308
1309 }
1310
1311 }
1312#ifdef ENABLE_CHECKING
1313 if (check_same_comdat_groups)
1314 FOR_EACH_FUNCTION (node)
1315 if (node->same_comdat_group && !node->process)
1316 {
1317 tree decl = node->decl;
1318 if (!node->global.inlined_to
1319 && gimple_has_body_p (decl)
1320 /* FIXME: in an ltrans unit when the offline copy is outside a
1321 partition but inline copies are inside a partition, we can
1322 end up not removing the body since we no longer have an
1323 analyzed node pointing to it. */
1324 && !node->in_other_partition
1325 && !node->clones
1326 && !DECL_EXTERNAL (decl))
1327 {
1328 node->debug ();
1329 internal_error ("failed to reclaim unneeded function in same "
1330 "comdat group");
1331 }
1332 }
1333#endif
1334}
1335
1336/* DECL is FUNCTION_DECL. Initialize datastructures so DECL is a function
1337 in lowered gimple form. IN_SSA is true if the gimple is in SSA.
1338
1339 Set current_function_decl and cfun to newly constructed empty function body.
1340 return basic block in the function body. */
1341
1342basic_block
1343init_lowered_empty_function (tree decl, bool in_ssa, gcov_type count)
1344{
1345 basic_block bb;
1346 edge e;
1347
1348 current_function_decl = decl;
1349 allocate_struct_function (decl, false);
1350 gimple_register_cfg_hooks ();
1351 init_empty_tree_cfg ();
1352
1353 if (in_ssa)
1354 {
1355 init_tree_ssa (cfun);
1356 init_ssa_operands (cfun);
1357 cfun->gimple_df->in_ssa_p = true;
1358 cfun->curr_properties |= PROP_ssa;
1359 }
1360
1361 DECL_INITIAL (decl) = make_node (BLOCK);
1362
1363 DECL_SAVED_TREE (decl) = error_mark_node;
1364 cfun->curr_properties |= (PROP_gimple_lcf | PROP_gimple_leh | PROP_gimple_any
1365 | PROP_cfg | PROP_loops);
1366
1367 set_loops_for_fn (cfun, ggc_cleared_alloc<loops> ());
1368 init_loops_structure (cfun, loops_for_fn (cfun), 1);
1369 loops_for_fn (cfun)->state |= LOOPS_MAY_HAVE_MULTIPLE_LATCHES;
1370
1371 /* Create BB for body of the function and connect it properly. */
1372 ENTRY_BLOCK_PTR_FOR_FN (cfun)->count = count;
1373 ENTRY_BLOCK_PTR_FOR_FN (cfun)->frequency = REG_BR_PROB_BASE;
1374 EXIT_BLOCK_PTR_FOR_FN (cfun)->count = count;
1375 EXIT_BLOCK_PTR_FOR_FN (cfun)->frequency = REG_BR_PROB_BASE;
1376 bb = create_basic_block (NULL, (void *) 0, ENTRY_BLOCK_PTR_FOR_FN (cfun));
1377 bb->count = count;
1378 bb->frequency = BB_FREQ_MAX;
1379 e = make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun), bb, EDGE_FALLTHRU);
1380 e->count = count;
1381 e->probability = REG_BR_PROB_BASE;
1382 e = make_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun), 0);
1383 e->count = count;
1384 e->probability = REG_BR_PROB_BASE;
1385 add_bb_to_loop (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun)->loop_father);
1386
1387 return bb;
1388}
1389
1390/* Adjust PTR by the constant FIXED_OFFSET, and by the vtable
1391 offset indicated by VIRTUAL_OFFSET, if that is
1392 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and
1393 zero for a result adjusting thunk. */
1394
1395static tree
1396thunk_adjust (gimple_stmt_iterator * bsi,
1397 tree ptr, bool this_adjusting,
1398 HOST_WIDE_INT fixed_offset, tree virtual_offset)
1399{
1400 gassign *stmt;
1401 tree ret;
1402
1403 if (this_adjusting
1404 && fixed_offset != 0)
1405 {
1406 stmt = gimple_build_assign
1407 (ptr, fold_build_pointer_plus_hwi_loc (input_location,
1408 ptr,
1409 fixed_offset));
1410 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1411 }
1412
1413 /* If there's a virtual offset, look up that value in the vtable and
1414 adjust the pointer again. */
1415 if (virtual_offset)
1416 {
1417 tree vtabletmp;
1418 tree vtabletmp2;
1419 tree vtabletmp3;
1420
1421 if (!vtable_entry_type)
1422 {
1423 tree vfunc_type = make_node (FUNCTION_TYPE);
1424 TREE_TYPE (vfunc_type) = integer_type_node;
1425 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE;
1426 layout_type (vfunc_type);
1427
1428 vtable_entry_type = build_pointer_type (vfunc_type);
1429 }
1430
1431 vtabletmp =
1432 create_tmp_reg (build_pointer_type
1433 (build_pointer_type (vtable_entry_type)), "vptr");
1434
1435 /* The vptr is always at offset zero in the object. */
1436 stmt = gimple_build_assign (vtabletmp,
1437 build1 (NOP_EXPR, TREE_TYPE (vtabletmp),
1438 ptr));
1439 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1440
1441 /* Form the vtable address. */
1442 vtabletmp2 = create_tmp_reg (TREE_TYPE (TREE_TYPE (vtabletmp)),
1443 "vtableaddr");
1444 stmt = gimple_build_assign (vtabletmp2,
1445 build_simple_mem_ref (vtabletmp));
1446 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1447
1448 /* Find the entry with the vcall offset. */
1449 stmt = gimple_build_assign (vtabletmp2,
1450 fold_build_pointer_plus_loc (input_location,
1451 vtabletmp2,
1452 virtual_offset));
1453 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1454
1455 /* Get the offset itself. */
1456 vtabletmp3 = create_tmp_reg (TREE_TYPE (TREE_TYPE (vtabletmp2)),
1457 "vcalloffset");
1458 stmt = gimple_build_assign (vtabletmp3,
1459 build_simple_mem_ref (vtabletmp2));
1460 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1461
1462 /* Adjust the `this' pointer. */
1463 ptr = fold_build_pointer_plus_loc (input_location, ptr, vtabletmp3);
1464 ptr = force_gimple_operand_gsi (bsi, ptr, true, NULL_TREE, false,
1465 GSI_CONTINUE_LINKING);
1466 }
1467
1468 if (!this_adjusting
1469 && fixed_offset != 0)
1470 /* Adjust the pointer by the constant. */
1471 {
1472 tree ptrtmp;
1473
1474 if (TREE_CODE (ptr) == VAR_DECL)
1475 ptrtmp = ptr;
1476 else
1477 {
1478 ptrtmp = create_tmp_reg (TREE_TYPE (ptr), "ptr");
1479 stmt = gimple_build_assign (ptrtmp, ptr);
1480 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1481 }
1482 ptr = fold_build_pointer_plus_hwi_loc (input_location,
1483 ptrtmp, fixed_offset);
1484 }
1485
1486 /* Emit the statement and gimplify the adjustment expression. */
1487 ret = create_tmp_reg (TREE_TYPE (ptr), "adjusted_this");
1488 stmt = gimple_build_assign (ret, ptr);
1489 gsi_insert_after (bsi, stmt, GSI_NEW_STMT);
1490
1491 return ret;
1492}
1493
1494/* Expand thunk NODE to gimple if possible.
1495 When FORCE_GIMPLE_THUNK is true, gimple thunk is created and
1496 no assembler is produced.
1497 When OUTPUT_ASM_THUNK is true, also produce assembler for
1498 thunks that are not lowered. */
1499
1500bool
1501cgraph_node::expand_thunk (bool output_asm_thunks, bool force_gimple_thunk)
1502{
1503 bool this_adjusting = thunk.this_adjusting;
1504 HOST_WIDE_INT fixed_offset = thunk.fixed_offset;
1505 HOST_WIDE_INT virtual_value = thunk.virtual_value;
1506 tree virtual_offset = NULL;
1507 tree alias = callees->callee->decl;
1508 tree thunk_fndecl = decl;
1509 tree a;
1510
1511
1512 if (!force_gimple_thunk && this_adjusting
1513 && targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset,
1514 virtual_value, alias))
1515 {
1516 const char *fnname;
1517 tree fn_block;
1518 tree restype = TREE_TYPE (TREE_TYPE (thunk_fndecl));
1519
1520 if (!output_asm_thunks)
1521 {
1522 analyzed = true;
1523 return false;
1524 }
1525
1526 if (in_lto_p)
1527 get_untransformed_body ();
1528 a = DECL_ARGUMENTS (thunk_fndecl);
1529
1530 current_function_decl = thunk_fndecl;
1531
1532 /* Ensure thunks are emitted in their correct sections. */
9f50539d
JM
1533 resolve_unique_section (thunk_fndecl, 0,
1534 flag_function_sections);
dda118e3
JM
1535
1536 DECL_RESULT (thunk_fndecl)
1537 = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl),
1538 RESULT_DECL, 0, restype);
1539 DECL_CONTEXT (DECL_RESULT (thunk_fndecl)) = thunk_fndecl;
1540 fnname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk_fndecl));
1541
1542 /* The back end expects DECL_INITIAL to contain a BLOCK, so we
1543 create one. */
1544 fn_block = make_node (BLOCK);
1545 BLOCK_VARS (fn_block) = a;
1546 DECL_INITIAL (thunk_fndecl) = fn_block;
1547 init_function_start (thunk_fndecl);
1548 cfun->is_thunk = 1;
1549 insn_locations_init ();
1550 set_curr_insn_location (DECL_SOURCE_LOCATION (thunk_fndecl));
1551 prologue_location = curr_insn_location ();
1552 assemble_start_function (thunk_fndecl, fnname);
1553
1554 targetm.asm_out.output_mi_thunk (asm_out_file, thunk_fndecl,
1555 fixed_offset, virtual_value, alias);
1556
1557 assemble_end_function (thunk_fndecl, fnname);
1558 insn_locations_finalize ();
1559 init_insn_lengths ();
1560 free_after_compilation (cfun);
1561 set_cfun (NULL);
1562 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
1563 thunk.thunk_p = false;
1564 analyzed = false;
1565 }
9f50539d
JM
1566 else if (stdarg_p (TREE_TYPE (thunk_fndecl)))
1567 {
1568 error ("generic thunk code fails for method %qD which uses %<...%>",
1569 thunk_fndecl);
1570 TREE_ASM_WRITTEN (thunk_fndecl) = 1;
1571 analyzed = true;
1572 return false;
1573 }
dda118e3
JM
1574 else
1575 {
1576 tree restype;
1577 basic_block bb, then_bb, else_bb, return_bb;
1578 gimple_stmt_iterator bsi;
1579 int nargs = 0;
1580 tree arg;
1581 int i;
1582 tree resdecl;
1583 tree restmp = NULL;
1584
1585 gcall *call;
1586 greturn *ret;
9f50539d 1587 bool alias_is_noreturn = TREE_THIS_VOLATILE (alias);
dda118e3
JM
1588
1589 if (in_lto_p)
1590 get_untransformed_body ();
1591 a = DECL_ARGUMENTS (thunk_fndecl);
1592
1593 current_function_decl = thunk_fndecl;
1594
1595 /* Ensure thunks are emitted in their correct sections. */
9f50539d
JM
1596 resolve_unique_section (thunk_fndecl, 0,
1597 flag_function_sections);
dda118e3
JM
1598
1599 DECL_IGNORED_P (thunk_fndecl) = 1;
1600 bitmap_obstack_initialize (NULL);
1601
1602 if (thunk.virtual_offset_p)
1603 virtual_offset = size_int (virtual_value);
1604
1605 /* Build the return declaration for the function. */
1606 restype = TREE_TYPE (TREE_TYPE (thunk_fndecl));
1607 if (DECL_RESULT (thunk_fndecl) == NULL_TREE)
1608 {
1609 resdecl = build_decl (input_location, RESULT_DECL, 0, restype);
1610 DECL_ARTIFICIAL (resdecl) = 1;
1611 DECL_IGNORED_P (resdecl) = 1;
1612 DECL_RESULT (thunk_fndecl) = resdecl;
1613 DECL_CONTEXT (DECL_RESULT (thunk_fndecl)) = thunk_fndecl;
1614 }
1615 else
1616 resdecl = DECL_RESULT (thunk_fndecl);
1617
1618 bb = then_bb = else_bb = return_bb
1619 = init_lowered_empty_function (thunk_fndecl, true, count);
1620
1621 bsi = gsi_start_bb (bb);
1622
1623 /* Build call to the function being thunked. */
9f50539d 1624 if (!VOID_TYPE_P (restype) && !alias_is_noreturn)
dda118e3
JM
1625 {
1626 if (DECL_BY_REFERENCE (resdecl))
1627 {
1628 restmp = gimple_fold_indirect_ref (resdecl);
1629 if (!restmp)
1630 restmp = build2 (MEM_REF,
1631 TREE_TYPE (TREE_TYPE (DECL_RESULT (alias))),
1632 resdecl,
1633 build_int_cst (TREE_TYPE
1634 (DECL_RESULT (alias)), 0));
1635 }
1636 else if (!is_gimple_reg_type (restype))
1637 {
9f50539d
JM
1638 if (aggregate_value_p (resdecl, TREE_TYPE (thunk_fndecl)))
1639 {
1640 restmp = resdecl;
dda118e3 1641
9f50539d
JM
1642 if (TREE_CODE (restmp) == VAR_DECL)
1643 add_local_decl (cfun, restmp);
1644 BLOCK_VARS (DECL_INITIAL (current_function_decl)) = restmp;
1645 }
1646 else
1647 restmp = create_tmp_var (restype, "retval");
dda118e3
JM
1648 }
1649 else
1650 restmp = create_tmp_reg (restype, "retval");
1651 }
1652
1653 for (arg = a; arg; arg = DECL_CHAIN (arg))
1654 nargs++;
1655 auto_vec<tree> vargs (nargs);
1656 i = 0;
1657 arg = a;
1658 if (this_adjusting)
1659 {
1660 vargs.quick_push (thunk_adjust (&bsi, a, 1, fixed_offset,
1661 virtual_offset));
1662 arg = DECL_CHAIN (a);
1663 i = 1;
1664 }
1665
1666 if (nargs)
1667 for (; i < nargs; i++, arg = DECL_CHAIN (arg))
1668 {
1669 tree tmp = arg;
1670 if (!is_gimple_val (arg))
1671 {
1672 tmp = create_tmp_reg (TYPE_MAIN_VARIANT
1673 (TREE_TYPE (arg)), "arg");
1674 gimple stmt = gimple_build_assign (tmp, arg);
1675 gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
1676 }
1677 vargs.quick_push (tmp);
1678 }
1679 call = gimple_build_call_vec (build_fold_addr_expr_loc (0, alias), vargs);
1680 callees->call_stmt = call;
1681 gimple_call_set_from_thunk (call, true);
1682 gimple_call_set_with_bounds (call, instrumentation_clone);
7de7a9db
JM
1683
1684 /* Return slot optimization is always possible and in fact requred to
1685 return values with DECL_BY_REFERENCE. */
1686 if (aggregate_value_p (resdecl, TREE_TYPE (thunk_fndecl))
1687 && (!is_gimple_reg_type (TREE_TYPE (resdecl))
1688 || DECL_BY_REFERENCE (resdecl)))
1689 gimple_call_set_return_slot_opt (call, true);
1690
9f50539d 1691 if (restmp && !alias_is_noreturn)
dda118e3
JM
1692 {
1693 gimple_call_set_lhs (call, restmp);
1694 gcc_assert (useless_type_conversion_p (TREE_TYPE (restmp),
1695 TREE_TYPE (TREE_TYPE (alias))));
1696 }
1697 gsi_insert_after (&bsi, call, GSI_NEW_STMT);
9f50539d 1698 if (!alias_is_noreturn)
dda118e3
JM
1699 {
1700 if (restmp && !this_adjusting
1701 && (fixed_offset || virtual_offset))
1702 {
1703 tree true_label = NULL_TREE;
1704
1705 if (TREE_CODE (TREE_TYPE (restmp)) == POINTER_TYPE)
1706 {
1707 gimple stmt;
1708 edge e;
1709 /* If the return type is a pointer, we need to
1710 protect against NULL. We know there will be an
1711 adjustment, because that's why we're emitting a
1712 thunk. */
1713 then_bb = create_basic_block (NULL, (void *) 0, bb);
1714 then_bb->count = count - count / 16;
1715 then_bb->frequency = BB_FREQ_MAX - BB_FREQ_MAX / 16;
1716 return_bb = create_basic_block (NULL, (void *) 0, then_bb);
1717 return_bb->count = count;
1718 return_bb->frequency = BB_FREQ_MAX;
1719 else_bb = create_basic_block (NULL, (void *) 0, else_bb);
1720 then_bb->count = count / 16;
1721 then_bb->frequency = BB_FREQ_MAX / 16;
1722 add_bb_to_loop (then_bb, bb->loop_father);
1723 add_bb_to_loop (return_bb, bb->loop_father);
1724 add_bb_to_loop (else_bb, bb->loop_father);
1725 remove_edge (single_succ_edge (bb));
1726 true_label = gimple_block_label (then_bb);
1727 stmt = gimple_build_cond (NE_EXPR, restmp,
1728 build_zero_cst (TREE_TYPE (restmp)),
1729 NULL_TREE, NULL_TREE);
1730 gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
1731 e = make_edge (bb, then_bb, EDGE_TRUE_VALUE);
1732 e->probability = REG_BR_PROB_BASE - REG_BR_PROB_BASE / 16;
1733 e->count = count - count / 16;
1734 e = make_edge (bb, else_bb, EDGE_FALSE_VALUE);
1735 e->probability = REG_BR_PROB_BASE / 16;
1736 e->count = count / 16;
1737 e = make_edge (return_bb, EXIT_BLOCK_PTR_FOR_FN (cfun), 0);
1738 e->probability = REG_BR_PROB_BASE;
1739 e->count = count;
1740 e = make_edge (then_bb, return_bb, EDGE_FALLTHRU);
1741 e->probability = REG_BR_PROB_BASE;
1742 e->count = count - count / 16;
1743 e = make_edge (else_bb, return_bb, EDGE_FALLTHRU);
1744 e->probability = REG_BR_PROB_BASE;
1745 e->count = count / 16;
1746 bsi = gsi_last_bb (then_bb);
1747 }
1748
1749 restmp = thunk_adjust (&bsi, restmp, /*this_adjusting=*/0,
1750 fixed_offset, virtual_offset);
1751 if (true_label)
1752 {
1753 gimple stmt;
1754 bsi = gsi_last_bb (else_bb);
1755 stmt = gimple_build_assign (restmp,
1756 build_zero_cst (TREE_TYPE (restmp)));
1757 gsi_insert_after (&bsi, stmt, GSI_NEW_STMT);
1758 bsi = gsi_last_bb (return_bb);
1759 }
1760 }
1761 else
1762 gimple_call_set_tail (call, true);
1763
1764 /* Build return value. */
1765 if (!DECL_BY_REFERENCE (resdecl))
1766 ret = gimple_build_return (restmp);
1767 else
1768 ret = gimple_build_return (resdecl);
1769
1770 gsi_insert_after (&bsi, ret, GSI_NEW_STMT);
1771 }
1772 else
1773 {
1774 gimple_call_set_tail (call, true);
1775 remove_edge (single_succ_edge (bb));
1776 }
1777
1778 cfun->gimple_df->in_ssa_p = true;
1779 profile_status_for_fn (cfun)
1780 = count ? PROFILE_READ : PROFILE_GUESSED;
1781 /* FIXME: C++ FE should stop setting TREE_ASM_WRITTEN on thunks. */
1782 TREE_ASM_WRITTEN (thunk_fndecl) = false;
1783 delete_unreachable_blocks ();
1784 update_ssa (TODO_update_ssa);
1785#ifdef ENABLE_CHECKING
1786 verify_flow_info ();
1787#endif
1788 free_dominance_info (CDI_DOMINATORS);
1789
1790 /* Since we want to emit the thunk, we explicitly mark its name as
1791 referenced. */
1792 thunk.thunk_p = false;
1793 lowered = true;
1794 bitmap_obstack_release (NULL);
1795 }
1796 current_function_decl = NULL;
1797 set_cfun (NULL);
1798 return true;
1799}
1800
1801/* Assemble thunks and aliases associated to node. */
1802
1803void
1804cgraph_node::assemble_thunks_and_aliases (void)
1805{
1806 cgraph_edge *e;
1807 ipa_ref *ref;
1808
1809 for (e = callers; e;)
1810 if (e->caller->thunk.thunk_p
1811 && !e->caller->thunk.add_pointer_bounds_args)
1812 {
1813 cgraph_node *thunk = e->caller;
1814
1815 e = e->next_caller;
1816 thunk->expand_thunk (true, false);
1817 thunk->assemble_thunks_and_aliases ();
1818 }
1819 else
1820 e = e->next_caller;
1821
1822 FOR_EACH_ALIAS (this, ref)
1823 {
1824 cgraph_node *alias = dyn_cast <cgraph_node *> (ref->referring);
1825 bool saved_written = TREE_ASM_WRITTEN (decl);
1826
1827 /* Force assemble_alias to really output the alias this time instead
1828 of buffering it in same alias pairs. */
1829 TREE_ASM_WRITTEN (decl) = 1;
1830 do_assemble_alias (alias->decl,
1831 DECL_ASSEMBLER_NAME (decl));
1832 alias->assemble_thunks_and_aliases ();
1833 TREE_ASM_WRITTEN (decl) = saved_written;
1834 }
1835}
1836
1837/* Expand function specified by node. */
1838
1839void
1840cgraph_node::expand (void)
1841{
1842 location_t saved_loc;
1843
1844 /* We ought to not compile any inline clones. */
1845 gcc_assert (!global.inlined_to);
1846
1847 announce_function (decl);
1848 process = 0;
1849 gcc_assert (lowered);
1850 get_untransformed_body ();
1851
1852 /* Generate RTL for the body of DECL. */
1853
1854 timevar_push (TV_REST_OF_COMPILATION);
1855
1856 gcc_assert (symtab->global_info_ready);
1857
1858 /* Initialize the default bitmap obstack. */
1859 bitmap_obstack_initialize (NULL);
1860
1861 /* Initialize the RTL code for the function. */
1862 current_function_decl = decl;
1863 saved_loc = input_location;
1864 input_location = DECL_SOURCE_LOCATION (decl);
1865 init_function_start (decl);
1866
1867 gimple_register_cfg_hooks ();
1868
1869 bitmap_obstack_initialize (&reg_obstack); /* FIXME, only at RTL generation*/
1870
1871 execute_all_ipa_transforms ();
1872
1873 /* Perform all tree transforms and optimizations. */
1874
1875 /* Signal the start of passes. */
1876 invoke_plugin_callbacks (PLUGIN_ALL_PASSES_START, NULL);
1877
1878 execute_pass_list (cfun, g->get_passes ()->all_passes);
1879
1880 /* Signal the end of passes. */
1881 invoke_plugin_callbacks (PLUGIN_ALL_PASSES_END, NULL);
1882
1883 bitmap_obstack_release (&reg_obstack);
1884
1885 /* Release the default bitmap obstack. */
1886 bitmap_obstack_release (NULL);
1887
1888 /* If requested, warn about function definitions where the function will
1889 return a value (usually of some struct or union type) which itself will
1890 take up a lot of stack space. */
1891 if (warn_larger_than && !DECL_EXTERNAL (decl) && TREE_TYPE (decl))
1892 {
1893 tree ret_type = TREE_TYPE (TREE_TYPE (decl));
1894
1895 if (ret_type && TYPE_SIZE_UNIT (ret_type)
1896 && TREE_CODE (TYPE_SIZE_UNIT (ret_type)) == INTEGER_CST
1897 && 0 < compare_tree_int (TYPE_SIZE_UNIT (ret_type),
1898 larger_than_size))
1899 {
1900 unsigned int size_as_int
1901 = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (ret_type));
1902
1903 if (compare_tree_int (TYPE_SIZE_UNIT (ret_type), size_as_int) == 0)
1904 warning (OPT_Wlarger_than_, "size of return value of %q+D is %u bytes",
1905 decl, size_as_int);
1906 else
1907 warning (OPT_Wlarger_than_, "size of return value of %q+D is larger than %wd bytes",
1908 decl, larger_than_size);
1909 }
1910 }
1911
1912 gimple_set_body (decl, NULL);
1913 if (DECL_STRUCT_FUNCTION (decl) == 0
1914 && !cgraph_node::get (decl)->origin)
1915 {
1916 /* Stop pointing to the local nodes about to be freed.
1917 But DECL_INITIAL must remain nonzero so we know this
1918 was an actual function definition.
1919 For a nested function, this is done in c_pop_function_context.
1920 If rest_of_compilation set this to 0, leave it 0. */
1921 if (DECL_INITIAL (decl) != 0)
1922 DECL_INITIAL (decl) = error_mark_node;
1923 }
1924
1925 input_location = saved_loc;
1926
1927 ggc_collect ();
1928 timevar_pop (TV_REST_OF_COMPILATION);
1929
1930 /* Make sure that BE didn't give up on compiling. */
1931 gcc_assert (TREE_ASM_WRITTEN (decl));
1932 set_cfun (NULL);
1933 current_function_decl = NULL;
1934
1935 /* It would make a lot more sense to output thunks before function body to get more
1936 forward and lest backwarding jumps. This however would need solving problem
1937 with comdats. See PR48668. Also aliases must come after function itself to
1938 make one pass assemblers, like one on AIX, happy. See PR 50689.
1939 FIXME: Perhaps thunks should be move before function IFF they are not in comdat
1940 groups. */
1941 assemble_thunks_and_aliases ();
1942 release_body ();
1943 /* Eliminate all call edges. This is important so the GIMPLE_CALL no longer
1944 points to the dead function body. */
1945 remove_callees ();
1946 remove_all_references ();
1947}
1948
1949/* Node comparer that is responsible for the order that corresponds
1950 to time when a function was launched for the first time. */
1951
1952static int
1953node_cmp (const void *pa, const void *pb)
1954{
1955 const cgraph_node *a = *(const cgraph_node * const *) pa;
1956 const cgraph_node *b = *(const cgraph_node * const *) pb;
1957
1958 /* Functions with time profile must be before these without profile. */
1959 if (!a->tp_first_run || !b->tp_first_run)
1960 return a->tp_first_run - b->tp_first_run;
1961
1962 return a->tp_first_run != b->tp_first_run
1963 ? b->tp_first_run - a->tp_first_run
1964 : b->order - a->order;
1965}
1966
1967/* Expand all functions that must be output.
1968
1969 Attempt to topologically sort the nodes so function is output when
1970 all called functions are already assembled to allow data to be
1971 propagated across the callgraph. Use a stack to get smaller distance
1972 between a function and its callees (later we may choose to use a more
1973 sophisticated algorithm for function reordering; we will likely want
1974 to use subsections to make the output functions appear in top-down
1975 order). */
1976
1977static void
1978expand_all_functions (void)
1979{
1980 cgraph_node *node;
1981 cgraph_node **order = XCNEWVEC (cgraph_node *,
1982 symtab->cgraph_count);
1983 unsigned int expanded_func_count = 0, profiled_func_count = 0;
1984 int order_pos, new_order_pos = 0;
1985 int i;
1986
1987 order_pos = ipa_reverse_postorder (order);
1988 gcc_assert (order_pos == symtab->cgraph_count);
1989
1990 /* Garbage collector may remove inline clones we eliminate during
1991 optimization. So we must be sure to not reference them. */
1992 for (i = 0; i < order_pos; i++)
1993 if (order[i]->process)
1994 order[new_order_pos++] = order[i];
1995
1996 if (flag_profile_reorder_functions)
1997 qsort (order, new_order_pos, sizeof (cgraph_node *), node_cmp);
1998
1999 for (i = new_order_pos - 1; i >= 0; i--)
2000 {
2001 node = order[i];
2002
2003 if (node->process)
2004 {
2005 expanded_func_count++;
2006 if(node->tp_first_run)
2007 profiled_func_count++;
2008
2009 if (symtab->dump_file)
2010 fprintf (symtab->dump_file,
2011 "Time profile order in expand_all_functions:%s:%d\n",
2012 node->asm_name (), node->tp_first_run);
2013 node->process = 0;
2014 node->expand ();
2015 }
2016 }
2017
2018 if (dump_file)
2019 fprintf (dump_file, "Expanded functions with time profile (%s):%u/%u\n",
2020 main_input_filename, profiled_func_count, expanded_func_count);
2021
2022 if (symtab->dump_file && flag_profile_reorder_functions)
2023 fprintf (symtab->dump_file, "Expanded functions with time profile:%u/%u\n",
2024 profiled_func_count, expanded_func_count);
2025
2026 symtab->process_new_functions ();
2027 free_gimplify_stack ();
2028
2029 free (order);
2030}
2031
2032/* This is used to sort the node types by the cgraph order number. */
2033
2034enum cgraph_order_sort_kind
2035{
2036 ORDER_UNDEFINED = 0,
2037 ORDER_FUNCTION,
2038 ORDER_VAR,
2039 ORDER_ASM
2040};
2041
2042struct cgraph_order_sort
2043{
2044 enum cgraph_order_sort_kind kind;
2045 union
2046 {
2047 cgraph_node *f;
2048 varpool_node *v;
2049 asm_node *a;
2050 } u;
2051};
2052
2053/* Output all functions, variables, and asm statements in the order
2054 according to their order fields, which is the order in which they
2055 appeared in the file. This implements -fno-toplevel-reorder. In
2056 this mode we may output functions and variables which don't really
2057 need to be output.
2058 When NO_REORDER is true only do this for symbols marked no reorder. */
2059
2060static void
2061output_in_order (bool no_reorder)
2062{
2063 int max;
2064 cgraph_order_sort *nodes;
2065 int i;
2066 cgraph_node *pf;
2067 varpool_node *pv;
2068 asm_node *pa;
2069 max = symtab->order;
2070 nodes = XCNEWVEC (cgraph_order_sort, max);
2071
2072 FOR_EACH_DEFINED_FUNCTION (pf)
2073 {
2074 if (pf->process && !pf->thunk.thunk_p && !pf->alias)
2075 {
2076 if (no_reorder && !pf->no_reorder)
2077 continue;
2078 i = pf->order;
2079 gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
2080 nodes[i].kind = ORDER_FUNCTION;
2081 nodes[i].u.f = pf;
2082 }
2083 }
2084
2085 FOR_EACH_DEFINED_VARIABLE (pv)
2086 if (!DECL_EXTERNAL (pv->decl))
2087 {
2088 if (no_reorder && !pv->no_reorder)
2089 continue;
2090 i = pv->order;
2091 gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
2092 nodes[i].kind = ORDER_VAR;
2093 nodes[i].u.v = pv;
2094 }
2095
2096 for (pa = symtab->first_asm_symbol (); pa; pa = pa->next)
2097 {
2098 i = pa->order;
2099 gcc_assert (nodes[i].kind == ORDER_UNDEFINED);
2100 nodes[i].kind = ORDER_ASM;
2101 nodes[i].u.a = pa;
2102 }
2103
2104 /* In toplevel reorder mode we output all statics; mark them as needed. */
2105
2106 for (i = 0; i < max; ++i)
2107 if (nodes[i].kind == ORDER_VAR)
2108 nodes[i].u.v->finalize_named_section_flags ();
2109
2110 for (i = 0; i < max; ++i)
2111 {
2112 switch (nodes[i].kind)
2113 {
2114 case ORDER_FUNCTION:
2115 nodes[i].u.f->process = 0;
2116 nodes[i].u.f->expand ();
2117 break;
2118
2119 case ORDER_VAR:
2120 nodes[i].u.v->assemble_decl ();
2121 break;
2122
2123 case ORDER_ASM:
2124 assemble_asm (nodes[i].u.a->asm_str);
2125 break;
2126
2127 case ORDER_UNDEFINED:
2128 break;
2129
2130 default:
2131 gcc_unreachable ();
2132 }
2133 }
2134
2135 symtab->clear_asm_symbols ();
2136
2137 free (nodes);
2138}
2139
2140static void
2141ipa_passes (void)
2142{
2143 gcc::pass_manager *passes = g->get_passes ();
2144
2145 set_cfun (NULL);
2146 current_function_decl = NULL;
2147 gimple_register_cfg_hooks ();
2148 bitmap_obstack_initialize (NULL);
2149
2150 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_START, NULL);
2151
2152 if (!in_lto_p)
2153 {
2154 execute_ipa_pass_list (passes->all_small_ipa_passes);
2155 if (seen_error ())
2156 return;
2157 }
2158
2159 /* This extra symtab_remove_unreachable_nodes pass tends to catch some
2160 devirtualization and other changes where removal iterate. */
2161 symtab->remove_unreachable_nodes (symtab->dump_file);
2162
2163 /* If pass_all_early_optimizations was not scheduled, the state of
2164 the cgraph will not be properly updated. Update it now. */
2165 if (symtab->state < IPA_SSA)
2166 symtab->state = IPA_SSA;
2167
2168 if (!in_lto_p)
2169 {
2170 /* Generate coverage variables and constructors. */
2171 coverage_finish ();
2172
2173 /* Process new functions added. */
2174 set_cfun (NULL);
2175 current_function_decl = NULL;
2176 symtab->process_new_functions ();
2177
2178 execute_ipa_summary_passes
2179 ((ipa_opt_pass_d *) passes->all_regular_ipa_passes);
2180 }
2181
2182 /* Some targets need to handle LTO assembler output specially. */
2183 if (flag_generate_lto || flag_generate_offload)
2184 targetm.asm_out.lto_start ();
2185
2186 if (!in_lto_p)
2187 {
2188 if (g->have_offload)
2189 {
2190 section_name_prefix = OFFLOAD_SECTION_NAME_PREFIX;
2191 lto_stream_offload_p = true;
2192 ipa_write_summaries ();
2193 lto_stream_offload_p = false;
2194 }
2195 if (flag_lto)
2196 {
2197 section_name_prefix = LTO_SECTION_NAME_PREFIX;
2198 lto_stream_offload_p = false;
2199 ipa_write_summaries ();
2200 }
2201 }
2202
2203 if (flag_generate_lto || flag_generate_offload)
2204 targetm.asm_out.lto_end ();
2205
2206 if (!flag_ltrans && (in_lto_p || !flag_lto || flag_fat_lto_objects))
2207 execute_ipa_pass_list (passes->all_regular_ipa_passes);
2208 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_END, NULL);
2209
2210 bitmap_obstack_release (NULL);
2211}
2212
2213
2214/* Return string alias is alias of. */
2215
2216static tree
2217get_alias_symbol (tree decl)
2218{
2219 tree alias = lookup_attribute ("alias", DECL_ATTRIBUTES (decl));
2220 return get_identifier (TREE_STRING_POINTER
2221 (TREE_VALUE (TREE_VALUE (alias))));
2222}
2223
2224
2225/* Weakrefs may be associated to external decls and thus not output
2226 at expansion time. Emit all necessary aliases. */
2227
2228void
2229symbol_table::output_weakrefs (void)
2230{
2231 symtab_node *node;
2232 cgraph_node *cnode;
2233 FOR_EACH_SYMBOL (node)
2234 if (node->alias
2235 && !TREE_ASM_WRITTEN (node->decl)
2236 && (!(cnode = dyn_cast <cgraph_node *> (node))
2237 || !cnode->instrumented_version
2238 || !TREE_ASM_WRITTEN (cnode->instrumented_version->decl))
2239 && node->weakref)
2240 {
2241 tree target;
2242
2243 /* Weakrefs are special by not requiring target definition in current
2244 compilation unit. It is thus bit hard to work out what we want to
2245 alias.
2246 When alias target is defined, we need to fetch it from symtab reference,
2247 otherwise it is pointed to by alias_target. */
2248 if (node->alias_target)
2249 target = (DECL_P (node->alias_target)
2250 ? DECL_ASSEMBLER_NAME (node->alias_target)
2251 : node->alias_target);
2252 else if (node->analyzed)
2253 target = DECL_ASSEMBLER_NAME (node->get_alias_target ()->decl);
2254 else
2255 {
2256 gcc_unreachable ();
2257 target = get_alias_symbol (node->decl);
2258 }
2259 do_assemble_alias (node->decl, target);
2260 }
2261}
2262
2263/* Perform simple optimizations based on callgraph. */
2264
2265void
2266symbol_table::compile (void)
2267{
2268 if (seen_error ())
2269 return;
2270
2271#ifdef ENABLE_CHECKING
2272 symtab_node::verify_symtab_nodes ();
2273#endif
2274
2275 timevar_push (TV_CGRAPHOPT);
2276 if (pre_ipa_mem_report)
2277 {
2278 fprintf (stderr, "Memory consumption before IPA\n");
2279 dump_memory_report (false);
2280 }
2281 if (!quiet_flag)
2282 fprintf (stderr, "Performing interprocedural optimizations\n");
2283 state = IPA;
2284
2285 /* Offloading requires LTO infrastructure. */
2286 if (!in_lto_p && g->have_offload)
2287 flag_generate_offload = 1;
2288
2289 /* If LTO is enabled, initialize the streamer hooks needed by GIMPLE. */
2290 if (flag_generate_lto || flag_generate_offload)
2291 lto_streamer_hooks_init ();
2292
2293 /* Don't run the IPA passes if there was any error or sorry messages. */
2294 if (!seen_error ())
2295 ipa_passes ();
2296
2297 /* Do nothing else if any IPA pass found errors or if we are just streaming LTO. */
2298 if (seen_error ()
2299 || (!in_lto_p && flag_lto && !flag_fat_lto_objects))
2300 {
2301 timevar_pop (TV_CGRAPHOPT);
2302 return;
2303 }
2304
2305 global_info_ready = true;
2306 if (dump_file)
2307 {
2308 fprintf (dump_file, "Optimized ");
2309 symtab_node:: dump_table (dump_file);
2310 }
2311 if (post_ipa_mem_report)
2312 {
2313 fprintf (stderr, "Memory consumption after IPA\n");
2314 dump_memory_report (false);
2315 }
2316 timevar_pop (TV_CGRAPHOPT);
2317
2318 /* Output everything. */
2319 (*debug_hooks->assembly_start) ();
2320 if (!quiet_flag)
2321 fprintf (stderr, "Assembling functions:\n");
2322#ifdef ENABLE_CHECKING
2323 symtab_node::verify_symtab_nodes ();
2324#endif
2325
2326 materialize_all_clones ();
2327 bitmap_obstack_initialize (NULL);
2328 execute_ipa_pass_list (g->get_passes ()->all_late_ipa_passes);
2329 bitmap_obstack_release (NULL);
2330 mark_functions_to_output ();
2331
2332 /* When weakref support is missing, we autmatically translate all
2333 references to NODE to references to its ultimate alias target.
2334 The renaming mechanizm uses flag IDENTIFIER_TRANSPARENT_ALIAS and
2335 TREE_CHAIN.
2336
2337 Set up this mapping before we output any assembler but once we are sure
2338 that all symbol renaming is done.
2339
2340 FIXME: All this uglyness can go away if we just do renaming at gimple
2341 level by physically rewritting the IL. At the moment we can only redirect
2342 calls, so we need infrastructure for renaming references as well. */
2343#ifndef ASM_OUTPUT_WEAKREF
2344 symtab_node *node;
2345
2346 FOR_EACH_SYMBOL (node)
2347 if (node->alias
2348 && lookup_attribute ("weakref", DECL_ATTRIBUTES (node->decl)))
2349 {
2350 IDENTIFIER_TRANSPARENT_ALIAS
2351 (DECL_ASSEMBLER_NAME (node->decl)) = 1;
2352 TREE_CHAIN (DECL_ASSEMBLER_NAME (node->decl))
2353 = (node->alias_target ? node->alias_target
2354 : DECL_ASSEMBLER_NAME (node->get_alias_target ()->decl));
2355 }
2356#endif
2357
2358 state = EXPANSION;
2359
2360 if (!flag_toplevel_reorder)
2361 output_in_order (false);
2362 else
2363 {
2364 /* Output first asm statements and anything ordered. The process
2365 flag is cleared for these nodes, so we skip them later. */
2366 output_in_order (true);
2367 expand_all_functions ();
2368 output_variables ();
2369 }
2370
2371 process_new_functions ();
2372 state = FINISHED;
2373 output_weakrefs ();
2374
2375 if (dump_file)
2376 {
2377 fprintf (dump_file, "\nFinal ");
2378 symtab_node::dump_table (dump_file);
2379 }
2380#ifdef ENABLE_CHECKING
2381 symtab_node::verify_symtab_nodes ();
2382 /* Double check that all inline clones are gone and that all
2383 function bodies have been released from memory. */
2384 if (!seen_error ())
2385 {
2386 cgraph_node *node;
2387 bool error_found = false;
2388
2389 FOR_EACH_DEFINED_FUNCTION (node)
2390 if (node->global.inlined_to
2391 || gimple_has_body_p (node->decl))
2392 {
2393 error_found = true;
2394 node->debug ();
2395 }
2396 if (error_found)
2397 internal_error ("nodes with unreleased memory found");
2398 }
2399#endif
2400}
2401
2402
2403/* Analyze the whole compilation unit once it is parsed completely. */
2404
2405void
2406symbol_table::finalize_compilation_unit (void)
2407{
2408 timevar_push (TV_CGRAPH);
2409
2410 /* If we're here there's no current function anymore. Some frontends
2411 are lazy in clearing these. */
2412 current_function_decl = NULL;
2413 set_cfun (NULL);
2414
2415 /* Do not skip analyzing the functions if there were errors, we
2416 miss diagnostics for following functions otherwise. */
2417
2418 /* Emit size functions we didn't inline. */
2419 finalize_size_functions ();
2420
2421 /* Mark alias targets necessary and emit diagnostics. */
2422 handle_alias_pairs ();
2423
2424 if (!quiet_flag)
2425 {
2426 fprintf (stderr, "\nAnalyzing compilation unit\n");
2427 fflush (stderr);
2428 }
2429
2430 if (flag_dump_passes)
2431 dump_passes ();
2432
2433 /* Gimplify and lower all functions, compute reachability and
2434 remove unreachable nodes. */
2435 analyze_functions ();
2436
2437 /* Mark alias targets necessary and emit diagnostics. */
2438 handle_alias_pairs ();
2439
2440 /* Gimplify and lower thunks. */
2441 analyze_functions ();
2442
2443 /* Finally drive the pass manager. */
2444 compile ();
2445
2446 timevar_pop (TV_CGRAPH);
2447}
2448
2449/* Reset all state within cgraphunit.c so that we can rerun the compiler
2450 within the same process. For use by toplev::finalize. */
2451
2452void
2453cgraphunit_c_finalize (void)
2454{
2455 gcc_assert (cgraph_new_nodes.length () == 0);
2456 cgraph_new_nodes.truncate (0);
2457
2458 vtable_entry_type = NULL;
2459 queued_nodes = &symtab_terminator;
2460
2461 first_analyzed = NULL;
2462 first_analyzed_var = NULL;
2463}
2464
2465/* Creates a wrapper from cgraph_node to TARGET node. Thunk is used for this
2466 kind of wrapper method. */
2467
2468void
2469cgraph_node::create_wrapper (cgraph_node *target)
2470{
2471 /* Preserve DECL_RESULT so we get right by reference flag. */
2472 tree decl_result = DECL_RESULT (decl);
2473
2474 /* Remove the function's body but keep arguments to be reused
2475 for thunk. */
2476 release_body (true);
2477 reset ();
2478
224ceb26 2479 DECL_UNINLINABLE (decl) = false;
dda118e3
JM
2480 DECL_RESULT (decl) = decl_result;
2481 DECL_INITIAL (decl) = NULL;
2482 allocate_struct_function (decl, false);
2483 set_cfun (NULL);
2484
2485 /* Turn alias into thunk and expand it into GIMPLE representation. */
2486 definition = true;
2487 thunk.thunk_p = true;
2488 thunk.this_adjusting = false;
2489 create_edge (target, NULL, count, CGRAPH_FREQ_BASE);
2490
2491 tree arguments = DECL_ARGUMENTS (decl);
2492
2493 while (arguments)
2494 {
2495 TREE_ADDRESSABLE (arguments) = false;
2496 arguments = TREE_CHAIN (arguments);
2497 }
2498
2499 expand_thunk (false, true);
2500
2501 /* Inline summary set-up. */
2502 analyze ();
2503 inline_analyze_function (this);
2504}
2505
2506#include "gt-cgraphunit.h"