annotate gcc/ipa.c @ 138:fc828634a951

merge
author Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date Thu, 08 Nov 2018 14:17:14 +0900
parents 84e7813d76e9
children 1830386684a0
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
1 /* Basic IPA optimizations and utilities.
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
2 Copyright (C) 2003-2018 Free Software Foundation, Inc.
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
3
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
4 This file is part of GCC.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
5
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
6 GCC is free software; you can redistribute it and/or modify it under
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
7 the terms of the GNU General Public License as published by the Free
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
8 Software Foundation; either version 3, or (at your option) any later
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
9 version.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
10
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
14 for more details.
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
15
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
16 You should have received a copy of the GNU General Public License
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
17 along with GCC; see the file COPYING3. If not see
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
18 <http://www.gnu.org/licenses/>. */
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
19
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
20 #include "config.h"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
21 #include "system.h"
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
22 #include "coretypes.h"
111
kono
parents: 67
diff changeset
23 #include "backend.h"
kono
parents: 67
diff changeset
24 #include "target.h"
kono
parents: 67
diff changeset
25 #include "tree.h"
55
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
26 #include "gimple.h"
111
kono
parents: 67
diff changeset
27 #include "alloc-pool.h"
kono
parents: 67
diff changeset
28 #include "tree-pass.h"
kono
parents: 67
diff changeset
29 #include "stringpool.h"
kono
parents: 67
diff changeset
30 #include "cgraph.h"
kono
parents: 67
diff changeset
31 #include "gimplify.h"
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
32 #include "tree-iterator.h"
111
kono
parents: 67
diff changeset
33 #include "ipa-utils.h"
kono
parents: 67
diff changeset
34 #include "symbol-summary.h"
kono
parents: 67
diff changeset
35 #include "tree-vrp.h"
kono
parents: 67
diff changeset
36 #include "ipa-prop.h"
kono
parents: 67
diff changeset
37 #include "ipa-fnsummary.h"
kono
parents: 67
diff changeset
38 #include "dbgcnt.h"
kono
parents: 67
diff changeset
39 #include "debug.h"
kono
parents: 67
diff changeset
40 #include "stringpool.h"
kono
parents: 67
diff changeset
41 #include "attribs.h"
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
42
111
kono
parents: 67
diff changeset
43 /* Return true when NODE has ADDR reference. */
kono
parents: 67
diff changeset
44
kono
parents: 67
diff changeset
45 static bool
kono
parents: 67
diff changeset
46 has_addr_references_p (struct cgraph_node *node,
kono
parents: 67
diff changeset
47 void *)
kono
parents: 67
diff changeset
48 {
kono
parents: 67
diff changeset
49 int i;
kono
parents: 67
diff changeset
50 struct ipa_ref *ref = NULL;
kono
parents: 67
diff changeset
51
kono
parents: 67
diff changeset
52 for (i = 0; node->iterate_referring (i, ref); i++)
kono
parents: 67
diff changeset
53 if (ref->use == IPA_REF_ADDR)
kono
parents: 67
diff changeset
54 return true;
kono
parents: 67
diff changeset
55 return false;
kono
parents: 67
diff changeset
56 }
kono
parents: 67
diff changeset
57
kono
parents: 67
diff changeset
58 /* Return true when NODE can be target of an indirect call. */
kono
parents: 67
diff changeset
59
kono
parents: 67
diff changeset
60 static bool
kono
parents: 67
diff changeset
61 is_indirect_call_target_p (struct cgraph_node *node, void *)
kono
parents: 67
diff changeset
62 {
kono
parents: 67
diff changeset
63 return node->indirect_call_target;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
64 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
65
55
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
66 /* Look for all functions inlined to NODE and update their inlined_to pointers
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
67 to INLINED_TO. */
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
68
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
69 static void
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
70 update_inlined_to_pointer (struct cgraph_node *node, struct cgraph_node *inlined_to)
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
71 {
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
72 struct cgraph_edge *e;
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
73 for (e = node->callees; e; e = e->next_callee)
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
74 if (e->callee->global.inlined_to)
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
75 {
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
76 e->callee->global.inlined_to = inlined_to;
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
77 update_inlined_to_pointer (e->callee, inlined_to);
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
78 }
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
79 }
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
80
111
kono
parents: 67
diff changeset
81 /* Add symtab NODE to queue starting at FIRST.
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
82
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
83 The queue is linked via AUX pointers and terminated by pointer to 1.
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
84 We enqueue nodes at two occasions: when we find them reachable or when we find
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
85 their bodies needed for further clonning. In the second case we mark them
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
86 by pointer to 2 after processing so they are re-queue when they become
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
87 reachable. */
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
88
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
89 static void
111
kono
parents: 67
diff changeset
90 enqueue_node (symtab_node *node, symtab_node **first,
kono
parents: 67
diff changeset
91 hash_set<symtab_node *> *reachable)
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
92 {
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
93 /* Node is still in queue; do nothing. */
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
94 if (node->aux && node->aux != (void *) 2)
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
95 return;
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
96 /* Node was already processed as unreachable, re-enqueue
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
97 only if it became reachable now. */
111
kono
parents: 67
diff changeset
98 if (node->aux == (void *)2 && !reachable->contains (node))
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
99 return;
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
100 node->aux = *first;
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
101 *first = node;
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
102 }
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
103
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
104 /* Process references. */
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
105
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
106 static void
111
kono
parents: 67
diff changeset
107 process_references (symtab_node *snode,
kono
parents: 67
diff changeset
108 symtab_node **first,
kono
parents: 67
diff changeset
109 bool before_inlining_p,
kono
parents: 67
diff changeset
110 hash_set<symtab_node *> *reachable)
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
111 {
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
112 int i;
111
kono
parents: 67
diff changeset
113 struct ipa_ref *ref = NULL;
kono
parents: 67
diff changeset
114 for (i = 0; snode->iterate_reference (i, ref); i++)
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
115 {
111
kono
parents: 67
diff changeset
116 symtab_node *node = ref->referred;
kono
parents: 67
diff changeset
117 symtab_node *body = node->ultimate_alias_target ();
kono
parents: 67
diff changeset
118
kono
parents: 67
diff changeset
119 if (node->definition && !node->in_other_partition
kono
parents: 67
diff changeset
120 && ((!DECL_EXTERNAL (node->decl) || node->alias)
kono
parents: 67
diff changeset
121 || (((before_inlining_p
kono
parents: 67
diff changeset
122 && (TREE_CODE (node->decl) != FUNCTION_DECL
kono
parents: 67
diff changeset
123 || (TREE_CODE (node->decl) == FUNCTION_DECL
kono
parents: 67
diff changeset
124 && opt_for_fn (body->decl, optimize))
kono
parents: 67
diff changeset
125 || (symtab->state < IPA_SSA
kono
parents: 67
diff changeset
126 && lookup_attribute
kono
parents: 67
diff changeset
127 ("always_inline",
kono
parents: 67
diff changeset
128 DECL_ATTRIBUTES (body->decl))))))
kono
parents: 67
diff changeset
129 /* We use variable constructors during late compilation for
kono
parents: 67
diff changeset
130 constant folding. Keep references alive so partitioning
kono
parents: 67
diff changeset
131 knows about potential references. */
kono
parents: 67
diff changeset
132 || (VAR_P (node->decl)
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
133 && (flag_wpa
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
134 || flag_incremental_link
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
135 == INCREMENTAL_LINK_LTO)
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
136 && dyn_cast <varpool_node *> (node)
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
137 ->ctor_useable_for_folding_p ()))))
111
kono
parents: 67
diff changeset
138 {
kono
parents: 67
diff changeset
139 /* Be sure that we will not optimize out alias target
kono
parents: 67
diff changeset
140 body. */
kono
parents: 67
diff changeset
141 if (DECL_EXTERNAL (node->decl)
kono
parents: 67
diff changeset
142 && node->alias
kono
parents: 67
diff changeset
143 && before_inlining_p)
kono
parents: 67
diff changeset
144 reachable->add (body);
kono
parents: 67
diff changeset
145 reachable->add (node);
kono
parents: 67
diff changeset
146 }
kono
parents: 67
diff changeset
147 enqueue_node (node, first, reachable);
kono
parents: 67
diff changeset
148 }
kono
parents: 67
diff changeset
149 }
kono
parents: 67
diff changeset
150
kono
parents: 67
diff changeset
151 /* EDGE is an polymorphic call. If BEFORE_INLINING_P is set, mark
kono
parents: 67
diff changeset
152 all its potential targets as reachable to permit later inlining if
kono
parents: 67
diff changeset
153 devirtualization happens. After inlining still keep their declarations
kono
parents: 67
diff changeset
154 around, so we can devirtualize to a direct call.
kono
parents: 67
diff changeset
155
kono
parents: 67
diff changeset
156 Also try to make trivial devirutalization when no or only one target is
kono
parents: 67
diff changeset
157 possible. */
kono
parents: 67
diff changeset
158
kono
parents: 67
diff changeset
159 static void
kono
parents: 67
diff changeset
160 walk_polymorphic_call_targets (hash_set<void *> *reachable_call_targets,
kono
parents: 67
diff changeset
161 struct cgraph_edge *edge,
kono
parents: 67
diff changeset
162 symtab_node **first,
kono
parents: 67
diff changeset
163 hash_set<symtab_node *> *reachable,
kono
parents: 67
diff changeset
164 bool before_inlining_p)
kono
parents: 67
diff changeset
165 {
kono
parents: 67
diff changeset
166 unsigned int i;
kono
parents: 67
diff changeset
167 void *cache_token;
kono
parents: 67
diff changeset
168 bool final;
kono
parents: 67
diff changeset
169 vec <cgraph_node *>targets
kono
parents: 67
diff changeset
170 = possible_polymorphic_call_targets
kono
parents: 67
diff changeset
171 (edge, &final, &cache_token);
kono
parents: 67
diff changeset
172
kono
parents: 67
diff changeset
173 if (!reachable_call_targets->add (cache_token))
kono
parents: 67
diff changeset
174 {
kono
parents: 67
diff changeset
175 for (i = 0; i < targets.length (); i++)
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
176 {
111
kono
parents: 67
diff changeset
177 struct cgraph_node *n = targets[i];
kono
parents: 67
diff changeset
178
kono
parents: 67
diff changeset
179 /* Do not bother to mark virtual methods in anonymous namespace;
kono
parents: 67
diff changeset
180 either we will find use of virtual table defining it, or it is
kono
parents: 67
diff changeset
181 unused. */
kono
parents: 67
diff changeset
182 if (TREE_CODE (TREE_TYPE (n->decl)) == METHOD_TYPE
kono
parents: 67
diff changeset
183 && type_in_anonymous_namespace_p
kono
parents: 67
diff changeset
184 (TYPE_METHOD_BASETYPE (TREE_TYPE (n->decl))))
kono
parents: 67
diff changeset
185 continue;
kono
parents: 67
diff changeset
186
kono
parents: 67
diff changeset
187 n->indirect_call_target = true;
kono
parents: 67
diff changeset
188 symtab_node *body = n->function_symbol ();
kono
parents: 67
diff changeset
189
kono
parents: 67
diff changeset
190 /* Prior inlining, keep alive bodies of possible targets for
kono
parents: 67
diff changeset
191 devirtualization. */
kono
parents: 67
diff changeset
192 if (n->definition
kono
parents: 67
diff changeset
193 && (before_inlining_p
kono
parents: 67
diff changeset
194 && opt_for_fn (body->decl, optimize)
kono
parents: 67
diff changeset
195 && opt_for_fn (body->decl, flag_devirtualize)))
kono
parents: 67
diff changeset
196 {
kono
parents: 67
diff changeset
197 /* Be sure that we will not optimize out alias target
kono
parents: 67
diff changeset
198 body. */
kono
parents: 67
diff changeset
199 if (DECL_EXTERNAL (n->decl)
kono
parents: 67
diff changeset
200 && n->alias
kono
parents: 67
diff changeset
201 && before_inlining_p)
kono
parents: 67
diff changeset
202 reachable->add (body);
kono
parents: 67
diff changeset
203 reachable->add (n);
kono
parents: 67
diff changeset
204 }
kono
parents: 67
diff changeset
205 /* Even after inlining we want to keep the possible targets in the
kono
parents: 67
diff changeset
206 boundary, so late passes can still produce direct call even if
kono
parents: 67
diff changeset
207 the chance for inlining is lost. */
kono
parents: 67
diff changeset
208 enqueue_node (n, first, reachable);
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
209 }
111
kono
parents: 67
diff changeset
210 }
kono
parents: 67
diff changeset
211
kono
parents: 67
diff changeset
212 /* Very trivial devirtualization; when the type is
kono
parents: 67
diff changeset
213 final or anonymous (so we know all its derivation)
kono
parents: 67
diff changeset
214 and there is only one possible virtual call target,
kono
parents: 67
diff changeset
215 make the edge direct. */
kono
parents: 67
diff changeset
216 if (final)
kono
parents: 67
diff changeset
217 {
kono
parents: 67
diff changeset
218 if (targets.length () <= 1 && dbg_cnt (devirt))
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
219 {
111
kono
parents: 67
diff changeset
220 cgraph_node *target, *node = edge->caller;
kono
parents: 67
diff changeset
221 if (targets.length () == 1)
kono
parents: 67
diff changeset
222 target = targets[0];
kono
parents: 67
diff changeset
223 else
kono
parents: 67
diff changeset
224 target = cgraph_node::get_create
kono
parents: 67
diff changeset
225 (builtin_decl_implicit (BUILT_IN_UNREACHABLE));
kono
parents: 67
diff changeset
226
kono
parents: 67
diff changeset
227 if (dump_enabled_p ())
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
228 {
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
229 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, edge->call_stmt,
111
kono
parents: 67
diff changeset
230 "devirtualizing call in %s to %s\n",
kono
parents: 67
diff changeset
231 edge->caller->dump_name (),
kono
parents: 67
diff changeset
232 target->dump_name ());
kono
parents: 67
diff changeset
233 }
kono
parents: 67
diff changeset
234 edge = edge->make_direct (target);
kono
parents: 67
diff changeset
235 if (ipa_fn_summaries)
kono
parents: 67
diff changeset
236 ipa_update_overall_fn_summary (node);
kono
parents: 67
diff changeset
237 else if (edge->call_stmt)
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
238 edge->redirect_call_stmt_to_callee ();
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
239 }
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
240 }
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
241 }
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
242
111
kono
parents: 67
diff changeset
243 /* Perform reachability analysis and reclaim all unreachable nodes.
kono
parents: 67
diff changeset
244
kono
parents: 67
diff changeset
245 The algorithm is basically mark&sweep but with some extra refinements:
kono
parents: 67
diff changeset
246
kono
parents: 67
diff changeset
247 - reachable extern inline functions needs special handling; the bodies needs
kono
parents: 67
diff changeset
248 to stay in memory until inlining in hope that they will be inlined.
kono
parents: 67
diff changeset
249 After inlining we release their bodies and turn them into unanalyzed
kono
parents: 67
diff changeset
250 nodes even when they are reachable.
kono
parents: 67
diff changeset
251
kono
parents: 67
diff changeset
252 - virtual functions are kept in callgraph even if they seem unreachable in
kono
parents: 67
diff changeset
253 hope calls to them will be devirtualized.
kono
parents: 67
diff changeset
254
kono
parents: 67
diff changeset
255 Again we remove them after inlining. In late optimization some
kono
parents: 67
diff changeset
256 devirtualization may happen, but it is not important since we won't inline
kono
parents: 67
diff changeset
257 the call. In theory early opts and IPA should work out all important cases.
kono
parents: 67
diff changeset
258
kono
parents: 67
diff changeset
259 - virtual clones needs bodies of their origins for later materialization;
kono
parents: 67
diff changeset
260 this means that we want to keep the body even if the origin is unreachable
kono
parents: 67
diff changeset
261 otherwise. To avoid origin from sitting in the callgraph and being
kono
parents: 67
diff changeset
262 walked by IPA passes, we turn them into unanalyzed nodes with body
kono
parents: 67
diff changeset
263 defined.
kono
parents: 67
diff changeset
264
kono
parents: 67
diff changeset
265 We maintain set of function declaration where body needs to stay in
kono
parents: 67
diff changeset
266 body_needed_for_clonning
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
267
111
kono
parents: 67
diff changeset
268 Inline clones represent special case: their declaration match the
kono
parents: 67
diff changeset
269 declaration of origin and cgraph_remove_node already knows how to
kono
parents: 67
diff changeset
270 reshape callgraph and preserve body when offline copy of function or
kono
parents: 67
diff changeset
271 inline clone is being removed.
kono
parents: 67
diff changeset
272
kono
parents: 67
diff changeset
273 - C++ virtual tables keyed to other unit are represented as DECL_EXTERNAL
kono
parents: 67
diff changeset
274 variables with DECL_INITIAL set. We finalize these and keep reachable
kono
parents: 67
diff changeset
275 ones around for constant folding purposes. After inlining we however
kono
parents: 67
diff changeset
276 stop walking their references to let everything static referneced by them
kono
parents: 67
diff changeset
277 to be removed when it is otherwise unreachable.
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
278
111
kono
parents: 67
diff changeset
279 We maintain queue of both reachable symbols (i.e. defined symbols that needs
kono
parents: 67
diff changeset
280 to stay) and symbols that are in boundary (i.e. external symbols referenced
kono
parents: 67
diff changeset
281 by reachable symbols or origins of clones). The queue is represented
kono
parents: 67
diff changeset
282 as linked list by AUX pointer terminated by 1.
kono
parents: 67
diff changeset
283
kono
parents: 67
diff changeset
284 At the end we keep all reachable symbols. For symbols in boundary we always
kono
parents: 67
diff changeset
285 turn definition into a declaration, but we may keep function body around
kono
parents: 67
diff changeset
286 based on body_needed_for_clonning
kono
parents: 67
diff changeset
287
kono
parents: 67
diff changeset
288 All symbols that enter the queue have AUX pointer non-zero and are in the
kono
parents: 67
diff changeset
289 boundary. Pointer set REACHABLE is used to track reachable symbols.
kono
parents: 67
diff changeset
290
kono
parents: 67
diff changeset
291 Every symbol can be visited twice - once as part of boundary and once
kono
parents: 67
diff changeset
292 as real reachable symbol. enqueue_node needs to decide whether the
kono
parents: 67
diff changeset
293 node needs to be re-queued for second processing. For this purpose
kono
parents: 67
diff changeset
294 we set AUX pointer of processed symbols in the boundary to constant 2. */
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
295
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
296 bool
111
kono
parents: 67
diff changeset
297 symbol_table::remove_unreachable_nodes (FILE *file)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
298 {
111
kono
parents: 67
diff changeset
299 symtab_node *first = (symtab_node *) (void *) 1;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
300 struct cgraph_node *node, *next;
111
kono
parents: 67
diff changeset
301 varpool_node *vnode, *vnext;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
302 bool changed = false;
111
kono
parents: 67
diff changeset
303 hash_set<symtab_node *> reachable;
kono
parents: 67
diff changeset
304 hash_set<tree> body_needed_for_clonning;
kono
parents: 67
diff changeset
305 hash_set<void *> reachable_call_targets;
kono
parents: 67
diff changeset
306 bool before_inlining_p = symtab->state < (!optimize && !in_lto_p ? IPA_SSA
kono
parents: 67
diff changeset
307 : IPA_SSA_AFTER_INLINING);
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
308
111
kono
parents: 67
diff changeset
309 timevar_push (TV_IPA_UNREACHABLE);
kono
parents: 67
diff changeset
310 build_type_inheritance_graph ();
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
311 if (file)
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
312 fprintf (file, "\nReclaiming functions:");
111
kono
parents: 67
diff changeset
313 if (flag_checking)
kono
parents: 67
diff changeset
314 {
kono
parents: 67
diff changeset
315 FOR_EACH_FUNCTION (node)
kono
parents: 67
diff changeset
316 gcc_assert (!node->aux);
kono
parents: 67
diff changeset
317 FOR_EACH_VARIABLE (vnode)
kono
parents: 67
diff changeset
318 gcc_assert (!vnode->aux);
kono
parents: 67
diff changeset
319 }
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
320 /* Mark functions whose bodies are obviously needed.
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
321 This is mostly when they can be referenced externally. Inline clones
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
322 are special since their declarations are shared with master clone and thus
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
323 cgraph_can_remove_if_no_direct_calls_and_refs_p should not be called on them. */
111
kono
parents: 67
diff changeset
324 FOR_EACH_FUNCTION (node)
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
325 {
111
kono
parents: 67
diff changeset
326 node->used_as_abstract_origin = false;
kono
parents: 67
diff changeset
327 node->indirect_call_target = false;
kono
parents: 67
diff changeset
328 if (node->definition
kono
parents: 67
diff changeset
329 && !node->global.inlined_to
kono
parents: 67
diff changeset
330 && !node->in_other_partition
kono
parents: 67
diff changeset
331 && !node->can_remove_if_no_direct_calls_and_refs_p ())
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
332 {
111
kono
parents: 67
diff changeset
333 gcc_assert (!node->global.inlined_to);
kono
parents: 67
diff changeset
334 reachable.add (node);
kono
parents: 67
diff changeset
335 enqueue_node (node, &first, &reachable);
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
336 }
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
337 else
111
kono
parents: 67
diff changeset
338 gcc_assert (!node->aux);
kono
parents: 67
diff changeset
339 }
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
340
111
kono
parents: 67
diff changeset
341 /* Mark variables that are obviously needed. */
kono
parents: 67
diff changeset
342 FOR_EACH_DEFINED_VARIABLE (vnode)
kono
parents: 67
diff changeset
343 if (!vnode->can_remove_if_no_refs_p()
kono
parents: 67
diff changeset
344 && !vnode->in_other_partition)
kono
parents: 67
diff changeset
345 {
kono
parents: 67
diff changeset
346 reachable.add (vnode);
kono
parents: 67
diff changeset
347 enqueue_node (vnode, &first, &reachable);
kono
parents: 67
diff changeset
348 }
kono
parents: 67
diff changeset
349
kono
parents: 67
diff changeset
350 /* Perform reachability analysis. */
kono
parents: 67
diff changeset
351 while (first != (symtab_node *) (void *) 1)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
352 {
111
kono
parents: 67
diff changeset
353 bool in_boundary_p = !reachable.contains (first);
kono
parents: 67
diff changeset
354 symtab_node *node = first;
kono
parents: 67
diff changeset
355
kono
parents: 67
diff changeset
356 first = (symtab_node *)first->aux;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
357
111
kono
parents: 67
diff changeset
358 /* If we are processing symbol in boundary, mark its AUX pointer for
kono
parents: 67
diff changeset
359 possible later re-processing in enqueue_node. */
kono
parents: 67
diff changeset
360 if (in_boundary_p)
kono
parents: 67
diff changeset
361 {
kono
parents: 67
diff changeset
362 node->aux = (void *)2;
kono
parents: 67
diff changeset
363 if (node->alias && node->analyzed)
kono
parents: 67
diff changeset
364 enqueue_node (node->get_alias_target (), &first, &reachable);
kono
parents: 67
diff changeset
365 }
kono
parents: 67
diff changeset
366 else
kono
parents: 67
diff changeset
367 {
kono
parents: 67
diff changeset
368 if (TREE_CODE (node->decl) == FUNCTION_DECL
kono
parents: 67
diff changeset
369 && DECL_ABSTRACT_ORIGIN (node->decl))
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
370 {
111
kono
parents: 67
diff changeset
371 struct cgraph_node *origin_node
kono
parents: 67
diff changeset
372 = cgraph_node::get (DECL_ABSTRACT_ORIGIN (node->decl));
kono
parents: 67
diff changeset
373 if (origin_node && !origin_node->used_as_abstract_origin)
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
374 {
111
kono
parents: 67
diff changeset
375 origin_node->used_as_abstract_origin = true;
kono
parents: 67
diff changeset
376 gcc_assert (!origin_node->prev_sibling_clone);
kono
parents: 67
diff changeset
377 gcc_assert (!origin_node->next_sibling_clone);
kono
parents: 67
diff changeset
378 for (cgraph_node *n = origin_node->clones; n;
kono
parents: 67
diff changeset
379 n = n->next_sibling_clone)
kono
parents: 67
diff changeset
380 if (n->decl == DECL_ABSTRACT_ORIGIN (node->decl))
kono
parents: 67
diff changeset
381 n->used_as_abstract_origin = true;
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
382 }
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
383 }
111
kono
parents: 67
diff changeset
384 /* If any symbol in a comdat group is reachable, force
kono
parents: 67
diff changeset
385 all externally visible symbols in the same comdat
kono
parents: 67
diff changeset
386 group to be reachable as well. Comdat-local symbols
kono
parents: 67
diff changeset
387 can be discarded if all uses were inlined. */
kono
parents: 67
diff changeset
388 if (node->same_comdat_group)
55
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
389 {
111
kono
parents: 67
diff changeset
390 symtab_node *next;
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
391 for (next = node->same_comdat_group;
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
392 next != node;
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
393 next = next->same_comdat_group)
111
kono
parents: 67
diff changeset
394 if (!next->comdat_local_p ()
kono
parents: 67
diff changeset
395 && !reachable.add (next))
kono
parents: 67
diff changeset
396 enqueue_node (next, &first, &reachable);
55
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
397 }
111
kono
parents: 67
diff changeset
398 /* Mark references as reachable. */
kono
parents: 67
diff changeset
399 process_references (node, &first, before_inlining_p, &reachable);
kono
parents: 67
diff changeset
400 }
kono
parents: 67
diff changeset
401
kono
parents: 67
diff changeset
402 if (cgraph_node *cnode = dyn_cast <cgraph_node *> (node))
kono
parents: 67
diff changeset
403 {
kono
parents: 67
diff changeset
404 /* Mark the callees reachable unless they are direct calls to extern
kono
parents: 67
diff changeset
405 inline functions we decided to not inline. */
kono
parents: 67
diff changeset
406 if (!in_boundary_p)
kono
parents: 67
diff changeset
407 {
kono
parents: 67
diff changeset
408 struct cgraph_edge *e;
kono
parents: 67
diff changeset
409 /* Keep alive possible targets for devirtualization. */
kono
parents: 67
diff changeset
410 if (opt_for_fn (cnode->decl, optimize)
kono
parents: 67
diff changeset
411 && opt_for_fn (cnode->decl, flag_devirtualize))
kono
parents: 67
diff changeset
412 {
kono
parents: 67
diff changeset
413 struct cgraph_edge *next;
kono
parents: 67
diff changeset
414 for (e = cnode->indirect_calls; e; e = next)
kono
parents: 67
diff changeset
415 {
kono
parents: 67
diff changeset
416 next = e->next_callee;
kono
parents: 67
diff changeset
417 if (e->indirect_info->polymorphic)
kono
parents: 67
diff changeset
418 walk_polymorphic_call_targets (&reachable_call_targets,
kono
parents: 67
diff changeset
419 e, &first, &reachable,
kono
parents: 67
diff changeset
420 before_inlining_p);
kono
parents: 67
diff changeset
421 }
kono
parents: 67
diff changeset
422 }
kono
parents: 67
diff changeset
423 for (e = cnode->callees; e; e = e->next_callee)
kono
parents: 67
diff changeset
424 {
kono
parents: 67
diff changeset
425 symtab_node *body = e->callee->function_symbol ();
kono
parents: 67
diff changeset
426 if (e->callee->definition
kono
parents: 67
diff changeset
427 && !e->callee->in_other_partition
kono
parents: 67
diff changeset
428 && (!e->inline_failed
kono
parents: 67
diff changeset
429 || !DECL_EXTERNAL (e->callee->decl)
kono
parents: 67
diff changeset
430 || e->callee->alias
kono
parents: 67
diff changeset
431 || (before_inlining_p
kono
parents: 67
diff changeset
432 && (opt_for_fn (body->decl, optimize)
kono
parents: 67
diff changeset
433 || (symtab->state < IPA_SSA
kono
parents: 67
diff changeset
434 && lookup_attribute
kono
parents: 67
diff changeset
435 ("always_inline",
kono
parents: 67
diff changeset
436 DECL_ATTRIBUTES (body->decl)))))))
kono
parents: 67
diff changeset
437 {
kono
parents: 67
diff changeset
438 /* Be sure that we will not optimize out alias target
kono
parents: 67
diff changeset
439 body. */
kono
parents: 67
diff changeset
440 if (DECL_EXTERNAL (e->callee->decl)
kono
parents: 67
diff changeset
441 && e->callee->alias
kono
parents: 67
diff changeset
442 && before_inlining_p)
kono
parents: 67
diff changeset
443 reachable.add (body);
kono
parents: 67
diff changeset
444 reachable.add (e->callee);
kono
parents: 67
diff changeset
445 }
kono
parents: 67
diff changeset
446 enqueue_node (e->callee, &first, &reachable);
kono
parents: 67
diff changeset
447 }
kono
parents: 67
diff changeset
448
kono
parents: 67
diff changeset
449 /* When inline clone exists, mark body to be preserved so when removing
kono
parents: 67
diff changeset
450 offline copy of the function we don't kill it. */
kono
parents: 67
diff changeset
451 if (cnode->global.inlined_to)
kono
parents: 67
diff changeset
452 body_needed_for_clonning.add (cnode->decl);
kono
parents: 67
diff changeset
453
kono
parents: 67
diff changeset
454 /* For non-inline clones, force their origins to the boundary and ensure
kono
parents: 67
diff changeset
455 that body is not removed. */
kono
parents: 67
diff changeset
456 while (cnode->clone_of)
kono
parents: 67
diff changeset
457 {
kono
parents: 67
diff changeset
458 bool noninline = cnode->clone_of->decl != cnode->decl;
kono
parents: 67
diff changeset
459 cnode = cnode->clone_of;
kono
parents: 67
diff changeset
460 if (noninline)
kono
parents: 67
diff changeset
461 {
kono
parents: 67
diff changeset
462 body_needed_for_clonning.add (cnode->decl);
kono
parents: 67
diff changeset
463 enqueue_node (cnode, &first, &reachable);
kono
parents: 67
diff changeset
464 }
kono
parents: 67
diff changeset
465 }
55
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
466
111
kono
parents: 67
diff changeset
467 }
kono
parents: 67
diff changeset
468 else if (cnode->thunk.thunk_p)
kono
parents: 67
diff changeset
469 enqueue_node (cnode->callees->callee, &first, &reachable);
kono
parents: 67
diff changeset
470
kono
parents: 67
diff changeset
471 /* If any reachable function has simd clones, mark them as
kono
parents: 67
diff changeset
472 reachable as well. */
kono
parents: 67
diff changeset
473 if (cnode->simd_clones)
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
474 {
111
kono
parents: 67
diff changeset
475 cgraph_node *next;
kono
parents: 67
diff changeset
476 for (next = cnode->simd_clones;
kono
parents: 67
diff changeset
477 next;
kono
parents: 67
diff changeset
478 next = next->simdclone->next_clone)
kono
parents: 67
diff changeset
479 if (in_boundary_p
kono
parents: 67
diff changeset
480 || !reachable.add (next))
kono
parents: 67
diff changeset
481 enqueue_node (next, &first, &reachable);
kono
parents: 67
diff changeset
482 }
kono
parents: 67
diff changeset
483 }
kono
parents: 67
diff changeset
484 /* When we see constructor of external variable, keep referred nodes in the
kono
parents: 67
diff changeset
485 boundary. This will also hold initializers of the external vars NODE
kono
parents: 67
diff changeset
486 refers to. */
kono
parents: 67
diff changeset
487 varpool_node *vnode = dyn_cast <varpool_node *> (node);
kono
parents: 67
diff changeset
488 if (vnode
kono
parents: 67
diff changeset
489 && DECL_EXTERNAL (node->decl)
kono
parents: 67
diff changeset
490 && !vnode->alias
kono
parents: 67
diff changeset
491 && in_boundary_p)
kono
parents: 67
diff changeset
492 {
kono
parents: 67
diff changeset
493 struct ipa_ref *ref = NULL;
kono
parents: 67
diff changeset
494 for (int i = 0; node->iterate_reference (i, ref); i++)
kono
parents: 67
diff changeset
495 enqueue_node (ref->referred, &first, &reachable);
kono
parents: 67
diff changeset
496 }
kono
parents: 67
diff changeset
497 }
kono
parents: 67
diff changeset
498
kono
parents: 67
diff changeset
499 /* Remove unreachable functions. */
kono
parents: 67
diff changeset
500 for (node = first_function (); node; node = next)
kono
parents: 67
diff changeset
501 {
kono
parents: 67
diff changeset
502 next = next_function (node);
kono
parents: 67
diff changeset
503
kono
parents: 67
diff changeset
504 /* If node is not needed at all, remove it. */
kono
parents: 67
diff changeset
505 if (!node->aux)
kono
parents: 67
diff changeset
506 {
kono
parents: 67
diff changeset
507 if (file)
kono
parents: 67
diff changeset
508 fprintf (file, " %s", node->dump_name ());
kono
parents: 67
diff changeset
509 node->remove ();
kono
parents: 67
diff changeset
510 changed = true;
kono
parents: 67
diff changeset
511 }
kono
parents: 67
diff changeset
512 /* If node is unreachable, remove its body. */
kono
parents: 67
diff changeset
513 else if (!reachable.contains (node))
kono
parents: 67
diff changeset
514 {
kono
parents: 67
diff changeset
515 /* We keep definitions of thunks and aliases in the boundary so
kono
parents: 67
diff changeset
516 we can walk to the ultimate alias targets and function symbols
kono
parents: 67
diff changeset
517 reliably. */
kono
parents: 67
diff changeset
518 if (node->alias || node->thunk.thunk_p)
kono
parents: 67
diff changeset
519 ;
kono
parents: 67
diff changeset
520 else if (!body_needed_for_clonning.contains (node->decl)
kono
parents: 67
diff changeset
521 && !node->alias && !node->thunk.thunk_p)
kono
parents: 67
diff changeset
522 node->release_body ();
kono
parents: 67
diff changeset
523 else if (!node->clone_of)
kono
parents: 67
diff changeset
524 gcc_assert (in_lto_p || DECL_RESULT (node->decl));
kono
parents: 67
diff changeset
525 if (node->definition && !node->alias && !node->thunk.thunk_p)
kono
parents: 67
diff changeset
526 {
kono
parents: 67
diff changeset
527 if (file)
kono
parents: 67
diff changeset
528 fprintf (file, " %s", node->dump_name ());
kono
parents: 67
diff changeset
529 node->body_removed = true;
kono
parents: 67
diff changeset
530 node->analyzed = false;
kono
parents: 67
diff changeset
531 node->definition = false;
kono
parents: 67
diff changeset
532 node->cpp_implicit_alias = false;
kono
parents: 67
diff changeset
533 node->alias = false;
kono
parents: 67
diff changeset
534 node->transparent_alias = false;
kono
parents: 67
diff changeset
535 node->thunk.thunk_p = false;
kono
parents: 67
diff changeset
536 node->weakref = false;
kono
parents: 67
diff changeset
537 /* After early inlining we drop always_inline attributes on
kono
parents: 67
diff changeset
538 bodies of functions that are still referenced (have their
kono
parents: 67
diff changeset
539 address taken). */
kono
parents: 67
diff changeset
540 DECL_ATTRIBUTES (node->decl)
kono
parents: 67
diff changeset
541 = remove_attribute ("always_inline",
kono
parents: 67
diff changeset
542 DECL_ATTRIBUTES (node->decl));
kono
parents: 67
diff changeset
543 if (!node->in_other_partition)
kono
parents: 67
diff changeset
544 node->local.local = false;
kono
parents: 67
diff changeset
545 node->remove_callees ();
kono
parents: 67
diff changeset
546 node->remove_all_references ();
kono
parents: 67
diff changeset
547 changed = true;
kono
parents: 67
diff changeset
548 if (node->thunk.thunk_p
kono
parents: 67
diff changeset
549 && node->thunk.add_pointer_bounds_args)
kono
parents: 67
diff changeset
550 {
kono
parents: 67
diff changeset
551 node->thunk.thunk_p = false;
kono
parents: 67
diff changeset
552 node->thunk.add_pointer_bounds_args = false;
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
553 }
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
554 }
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
555 }
111
kono
parents: 67
diff changeset
556 else
kono
parents: 67
diff changeset
557 gcc_assert (node->clone_of || !node->has_gimple_body_p ()
kono
parents: 67
diff changeset
558 || in_lto_p || DECL_RESULT (node->decl));
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
559 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
560
111
kono
parents: 67
diff changeset
561 /* Inline clones might be kept around so their materializing allows further
kono
parents: 67
diff changeset
562 cloning. If the function the clone is inlined into is removed, we need
kono
parents: 67
diff changeset
563 to turn it into normal cone. */
kono
parents: 67
diff changeset
564 FOR_EACH_FUNCTION (node)
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
565 {
55
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
566 if (node->global.inlined_to
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
567 && !node->callers)
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
568 {
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
569 gcc_assert (node->clones);
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
570 node->global.inlined_to = NULL;
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
571 update_inlined_to_pointer (node, node);
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
572 }
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
573 node->aux = NULL;
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
574 }
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
575
111
kono
parents: 67
diff changeset
576 /* Remove unreachable variables. */
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
577 if (file)
111
kono
parents: 67
diff changeset
578 fprintf (file, "\nReclaiming variables:");
kono
parents: 67
diff changeset
579 for (vnode = first_variable (); vnode; vnode = vnext)
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
580 {
111
kono
parents: 67
diff changeset
581 vnext = next_variable (vnode);
kono
parents: 67
diff changeset
582 if (!vnode->aux
kono
parents: 67
diff changeset
583 /* For can_refer_decl_in_current_unit_p we want to track for
kono
parents: 67
diff changeset
584 all external variables if they are defined in other partition
kono
parents: 67
diff changeset
585 or not. */
kono
parents: 67
diff changeset
586 && (!flag_ltrans || !DECL_EXTERNAL (vnode->decl)))
kono
parents: 67
diff changeset
587 {
kono
parents: 67
diff changeset
588 struct ipa_ref *ref = NULL;
kono
parents: 67
diff changeset
589
kono
parents: 67
diff changeset
590 /* First remove the aliases, so varpool::remove can possibly lookup
kono
parents: 67
diff changeset
591 the constructor and save it for future use. */
kono
parents: 67
diff changeset
592 while (vnode->iterate_direct_aliases (0, ref))
kono
parents: 67
diff changeset
593 {
kono
parents: 67
diff changeset
594 if (file)
kono
parents: 67
diff changeset
595 fprintf (file, " %s", ref->referred->dump_name ());
kono
parents: 67
diff changeset
596 ref->referring->remove ();
kono
parents: 67
diff changeset
597 }
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
598 if (file)
111
kono
parents: 67
diff changeset
599 fprintf (file, " %s", vnode->dump_name ());
kono
parents: 67
diff changeset
600 vnext = next_variable (vnode);
kono
parents: 67
diff changeset
601 /* Signal removal to the debug machinery. */
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
602 if (! flag_wpa || flag_incremental_link == INCREMENTAL_LINK_LTO)
111
kono
parents: 67
diff changeset
603 {
kono
parents: 67
diff changeset
604 vnode->definition = false;
kono
parents: 67
diff changeset
605 (*debug_hooks->late_global_decl) (vnode->decl);
kono
parents: 67
diff changeset
606 }
kono
parents: 67
diff changeset
607 vnode->remove ();
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
608 changed = true;
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
609 }
111
kono
parents: 67
diff changeset
610 else if (!reachable.contains (vnode) && !vnode->alias)
kono
parents: 67
diff changeset
611 {
kono
parents: 67
diff changeset
612 tree init;
kono
parents: 67
diff changeset
613 if (vnode->definition)
kono
parents: 67
diff changeset
614 {
kono
parents: 67
diff changeset
615 if (file)
kono
parents: 67
diff changeset
616 fprintf (file, " %s", vnode->name ());
kono
parents: 67
diff changeset
617 changed = true;
kono
parents: 67
diff changeset
618 }
kono
parents: 67
diff changeset
619 /* Keep body if it may be useful for constant folding. */
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
620 if ((flag_wpa || flag_incremental_link == INCREMENTAL_LINK_LTO)
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
621 || ((init = ctor_for_folding (vnode->decl)) == error_mark_node))
111
kono
parents: 67
diff changeset
622 vnode->remove_initializer ();
kono
parents: 67
diff changeset
623 else
kono
parents: 67
diff changeset
624 DECL_INITIAL (vnode->decl) = init;
kono
parents: 67
diff changeset
625 vnode->body_removed = true;
kono
parents: 67
diff changeset
626 vnode->definition = false;
kono
parents: 67
diff changeset
627 vnode->analyzed = false;
kono
parents: 67
diff changeset
628 vnode->aux = NULL;
kono
parents: 67
diff changeset
629
kono
parents: 67
diff changeset
630 vnode->remove_from_same_comdat_group ();
kono
parents: 67
diff changeset
631
kono
parents: 67
diff changeset
632 vnode->remove_all_references ();
kono
parents: 67
diff changeset
633 }
kono
parents: 67
diff changeset
634 else
kono
parents: 67
diff changeset
635 vnode->aux = NULL;
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
636 }
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
637
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
638 /* Now update address_taken flags and try to promote functions to be local. */
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
639 if (file)
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
640 fprintf (file, "\nClearing address taken flags:");
111
kono
parents: 67
diff changeset
641 FOR_EACH_DEFINED_FUNCTION (node)
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
642 if (node->address_taken
111
kono
parents: 67
diff changeset
643 && !node->used_from_other_partition)
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
644 {
111
kono
parents: 67
diff changeset
645 if (!node->call_for_symbol_and_aliases
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
646 (has_addr_references_p, NULL, true))
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
647 {
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
648 if (file)
111
kono
parents: 67
diff changeset
649 fprintf (file, " %s", node->name ());
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
650 node->address_taken = false;
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
651 changed = true;
111
kono
parents: 67
diff changeset
652 if (node->local_p ()
kono
parents: 67
diff changeset
653 /* Virtual functions may be kept in cgraph just because
kono
parents: 67
diff changeset
654 of possible later devirtualization. Do not mark them as
kono
parents: 67
diff changeset
655 local too early so we won't optimize them out before
kono
parents: 67
diff changeset
656 we are done with polymorphic call analysis. */
kono
parents: 67
diff changeset
657 && (!before_inlining_p
kono
parents: 67
diff changeset
658 || !node->call_for_symbol_and_aliases
kono
parents: 67
diff changeset
659 (is_indirect_call_target_p, NULL, true)))
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
660 {
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
661 node->local.local = true;
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
662 if (file)
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
663 fprintf (file, " (local)");
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
664 }
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
665 }
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
666 }
111
kono
parents: 67
diff changeset
667 if (file)
kono
parents: 67
diff changeset
668 fprintf (file, "\n");
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
669
111
kono
parents: 67
diff changeset
670 symtab_node::checking_verify_symtab_nodes ();
kono
parents: 67
diff changeset
671
kono
parents: 67
diff changeset
672 /* If we removed something, perhaps profile could be improved. */
kono
parents: 67
diff changeset
673 if (changed && (optimize || in_lto_p) && ipa_call_summaries)
kono
parents: 67
diff changeset
674 FOR_EACH_DEFINED_FUNCTION (node)
kono
parents: 67
diff changeset
675 ipa_propagate_frequency (node);
kono
parents: 67
diff changeset
676
kono
parents: 67
diff changeset
677 timevar_pop (TV_IPA_UNREACHABLE);
kono
parents: 67
diff changeset
678 return changed;
kono
parents: 67
diff changeset
679 }
kono
parents: 67
diff changeset
680
kono
parents: 67
diff changeset
681 /* Process references to VNODE and set flags WRITTEN, ADDRESS_TAKEN, READ
kono
parents: 67
diff changeset
682 as needed, also clear EXPLICIT_REFS if the references to given variable
kono
parents: 67
diff changeset
683 do not need to be explicit. */
kono
parents: 67
diff changeset
684
kono
parents: 67
diff changeset
685 void
kono
parents: 67
diff changeset
686 process_references (varpool_node *vnode,
kono
parents: 67
diff changeset
687 bool *written, bool *address_taken,
kono
parents: 67
diff changeset
688 bool *read, bool *explicit_refs)
kono
parents: 67
diff changeset
689 {
kono
parents: 67
diff changeset
690 int i;
kono
parents: 67
diff changeset
691 struct ipa_ref *ref;
kono
parents: 67
diff changeset
692
kono
parents: 67
diff changeset
693 if (!vnode->all_refs_explicit_p ()
kono
parents: 67
diff changeset
694 || TREE_THIS_VOLATILE (vnode->decl))
kono
parents: 67
diff changeset
695 *explicit_refs = false;
55
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
696
111
kono
parents: 67
diff changeset
697 for (i = 0; vnode->iterate_referring (i, ref)
kono
parents: 67
diff changeset
698 && *explicit_refs && (!*written || !*address_taken || !*read); i++)
kono
parents: 67
diff changeset
699 switch (ref->use)
kono
parents: 67
diff changeset
700 {
kono
parents: 67
diff changeset
701 case IPA_REF_ADDR:
kono
parents: 67
diff changeset
702 *address_taken = true;
kono
parents: 67
diff changeset
703 break;
kono
parents: 67
diff changeset
704 case IPA_REF_LOAD:
kono
parents: 67
diff changeset
705 *read = true;
kono
parents: 67
diff changeset
706 break;
kono
parents: 67
diff changeset
707 case IPA_REF_STORE:
kono
parents: 67
diff changeset
708 *written = true;
kono
parents: 67
diff changeset
709 break;
kono
parents: 67
diff changeset
710 case IPA_REF_ALIAS:
kono
parents: 67
diff changeset
711 process_references (dyn_cast<varpool_node *> (ref->referring), written,
kono
parents: 67
diff changeset
712 address_taken, read, explicit_refs);
kono
parents: 67
diff changeset
713 break;
kono
parents: 67
diff changeset
714 }
kono
parents: 67
diff changeset
715 }
kono
parents: 67
diff changeset
716
kono
parents: 67
diff changeset
717 /* Set TREE_READONLY bit. */
55
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
718
111
kono
parents: 67
diff changeset
719 bool
kono
parents: 67
diff changeset
720 set_readonly_bit (varpool_node *vnode, void *data ATTRIBUTE_UNUSED)
kono
parents: 67
diff changeset
721 {
kono
parents: 67
diff changeset
722 TREE_READONLY (vnode->decl) = true;
kono
parents: 67
diff changeset
723 return false;
kono
parents: 67
diff changeset
724 }
kono
parents: 67
diff changeset
725
kono
parents: 67
diff changeset
726 /* Set writeonly bit and clear the initalizer, since it will not be needed. */
kono
parents: 67
diff changeset
727
kono
parents: 67
diff changeset
728 bool
kono
parents: 67
diff changeset
729 set_writeonly_bit (varpool_node *vnode, void *data)
kono
parents: 67
diff changeset
730 {
kono
parents: 67
diff changeset
731 vnode->writeonly = true;
kono
parents: 67
diff changeset
732 if (optimize || in_lto_p)
kono
parents: 67
diff changeset
733 {
kono
parents: 67
diff changeset
734 DECL_INITIAL (vnode->decl) = NULL;
kono
parents: 67
diff changeset
735 if (!vnode->alias)
kono
parents: 67
diff changeset
736 {
kono
parents: 67
diff changeset
737 if (vnode->num_references ())
kono
parents: 67
diff changeset
738 *(bool *)data = true;
kono
parents: 67
diff changeset
739 vnode->remove_all_references ();
kono
parents: 67
diff changeset
740 }
kono
parents: 67
diff changeset
741 }
kono
parents: 67
diff changeset
742 return false;
kono
parents: 67
diff changeset
743 }
kono
parents: 67
diff changeset
744
kono
parents: 67
diff changeset
745 /* Clear addressale bit of VNODE. */
kono
parents: 67
diff changeset
746
kono
parents: 67
diff changeset
747 bool
kono
parents: 67
diff changeset
748 clear_addressable_bit (varpool_node *vnode, void *data ATTRIBUTE_UNUSED)
kono
parents: 67
diff changeset
749 {
kono
parents: 67
diff changeset
750 vnode->address_taken = false;
kono
parents: 67
diff changeset
751 TREE_ADDRESSABLE (vnode->decl) = 0;
kono
parents: 67
diff changeset
752 return false;
0
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
753 }
a06113de4d67 first commit
kent <kent@cr.ie.u-ryukyu.ac.jp>
parents:
diff changeset
754
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
755 /* Discover variables that have no longer address taken or that are read only
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
756 and update their flags.
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
757
111
kono
parents: 67
diff changeset
758 Return true when unreachable symbol removan should be done.
kono
parents: 67
diff changeset
759
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
760 FIXME: This can not be done in between gimplify and omp_expand since
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
761 readonly flag plays role on what is shared and what is not. Currently we do
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
762 this transformation as part of whole program visibility and re-do at
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
763 ipa-reference pass (to take into account clonning), but it would
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
764 make sense to do it before early optimizations. */
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
765
111
kono
parents: 67
diff changeset
766 bool
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
767 ipa_discover_readonly_nonaddressable_vars (void)
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
768 {
111
kono
parents: 67
diff changeset
769 bool remove_p = false;
kono
parents: 67
diff changeset
770 varpool_node *vnode;
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
771 if (dump_file)
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
772 fprintf (dump_file, "Clearing variable flags:");
111
kono
parents: 67
diff changeset
773 FOR_EACH_VARIABLE (vnode)
kono
parents: 67
diff changeset
774 if (!vnode->alias
kono
parents: 67
diff changeset
775 && (TREE_ADDRESSABLE (vnode->decl)
kono
parents: 67
diff changeset
776 || !vnode->writeonly
kono
parents: 67
diff changeset
777 || !TREE_READONLY (vnode->decl)))
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
778 {
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
779 bool written = false;
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
780 bool address_taken = false;
111
kono
parents: 67
diff changeset
781 bool read = false;
kono
parents: 67
diff changeset
782 bool explicit_refs = true;
kono
parents: 67
diff changeset
783
kono
parents: 67
diff changeset
784 process_references (vnode, &written, &address_taken, &read,
kono
parents: 67
diff changeset
785 &explicit_refs);
kono
parents: 67
diff changeset
786 if (!explicit_refs)
kono
parents: 67
diff changeset
787 continue;
kono
parents: 67
diff changeset
788 if (!address_taken)
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
789 {
111
kono
parents: 67
diff changeset
790 if (TREE_ADDRESSABLE (vnode->decl) && dump_file)
kono
parents: 67
diff changeset
791 fprintf (dump_file, " %s (non-addressable)", vnode->name ());
kono
parents: 67
diff changeset
792 vnode->call_for_symbol_and_aliases (clear_addressable_bit, NULL,
kono
parents: 67
diff changeset
793 true);
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
794 }
111
kono
parents: 67
diff changeset
795 if (!address_taken && !written
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
796 /* Making variable in explicit section readonly can cause section
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
797 type conflict.
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
798 See e.g. gcc.c-torture/compile/pr23237.c */
111
kono
parents: 67
diff changeset
799 && vnode->get_section () == NULL)
kono
parents: 67
diff changeset
800 {
kono
parents: 67
diff changeset
801 if (!TREE_READONLY (vnode->decl) && dump_file)
kono
parents: 67
diff changeset
802 fprintf (dump_file, " %s (read-only)", vnode->name ());
kono
parents: 67
diff changeset
803 vnode->call_for_symbol_and_aliases (set_readonly_bit, NULL, true);
kono
parents: 67
diff changeset
804 }
kono
parents: 67
diff changeset
805 if (!vnode->writeonly && !read && !address_taken && written)
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
806 {
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
807 if (dump_file)
111
kono
parents: 67
diff changeset
808 fprintf (dump_file, " %s (write-only)", vnode->name ());
kono
parents: 67
diff changeset
809 vnode->call_for_symbol_and_aliases (set_writeonly_bit, &remove_p,
kono
parents: 67
diff changeset
810 true);
63
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
811 }
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
812 }
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
813 if (dump_file)
b7f97abdc517 update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 55
diff changeset
814 fprintf (dump_file, "\n");
111
kono
parents: 67
diff changeset
815 return remove_p;
55
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
816 }
77e2b8dfacca update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents: 0
diff changeset
817
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
818 /* Generate and emit a static constructor or destructor. WHICH must
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
819 be one of 'I' (for a constructor), 'D' (for a destructor).
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
820 BODY is a STATEMENT_LIST containing GENERIC
111
kono
parents: 67
diff changeset
821 statements. PRIORITY is the initialization priority for this
kono
parents: 67
diff changeset
822 constructor or destructor.
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
823
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
824 FINAL specify whether the externally visible name for collect2 should
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
825 be produced. */
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
826
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
827 static void
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
828 cgraph_build_static_cdtor_1 (char which, tree body, int priority, bool final)
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
829 {
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
830 static int counter = 0;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
831 char which_buf[16];
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
832 tree decl, name, resdecl;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
833
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
834 /* The priority is encoded in the constructor or destructor name.
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
835 collect2 will sort the names and arrange that they are called at
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
836 program startup. */
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
837 if (final)
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
838 sprintf (which_buf, "%c_%.5d_%d", which, priority, counter++);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
839 else
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
840 /* Proudce sane name but one not recognizable by collect2, just for the
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
841 case we fail to inline the function. */
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
842 sprintf (which_buf, "sub_%c_%.5d_%d", which, priority, counter++);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
843 name = get_file_function_name (which_buf);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
844
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
845 decl = build_decl (input_location, FUNCTION_DECL, name,
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
846 build_function_type_list (void_type_node, NULL_TREE));
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
847 current_function_decl = decl;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
848
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
849 resdecl = build_decl (input_location,
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
850 RESULT_DECL, NULL_TREE, void_type_node);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
851 DECL_ARTIFICIAL (resdecl) = 1;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
852 DECL_RESULT (decl) = resdecl;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
853 DECL_CONTEXT (resdecl) = decl;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
854
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
855 allocate_struct_function (decl, false);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
856
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
857 TREE_STATIC (decl) = 1;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
858 TREE_USED (decl) = 1;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
859 DECL_ARTIFICIAL (decl) = 1;
111
kono
parents: 67
diff changeset
860 DECL_IGNORED_P (decl) = 1;
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
861 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
862 DECL_SAVED_TREE (decl) = body;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
863 if (!targetm.have_ctors_dtors && final)
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
864 {
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
865 TREE_PUBLIC (decl) = 1;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
866 DECL_PRESERVE_P (decl) = 1;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
867 }
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
868 DECL_UNINLINABLE (decl) = 1;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
869
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
870 DECL_INITIAL (decl) = make_node (BLOCK);
111
kono
parents: 67
diff changeset
871 BLOCK_SUPERCONTEXT (DECL_INITIAL (decl)) = decl;
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
872 TREE_USED (DECL_INITIAL (decl)) = 1;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
873
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
874 DECL_SOURCE_LOCATION (decl) = input_location;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
875 cfun->function_end_locus = input_location;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
876
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
877 switch (which)
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
878 {
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
879 case 'I':
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
880 DECL_STATIC_CONSTRUCTOR (decl) = 1;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
881 decl_init_priority_insert (decl, priority);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
882 break;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
883 case 'D':
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
884 DECL_STATIC_DESTRUCTOR (decl) = 1;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
885 decl_fini_priority_insert (decl, priority);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
886 break;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
887 default:
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
888 gcc_unreachable ();
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
889 }
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
890
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
891 gimplify_function_tree (decl);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
892
111
kono
parents: 67
diff changeset
893 cgraph_node::add_new_function (decl, false);
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
894
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
895 set_cfun (NULL);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
896 current_function_decl = NULL;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
897 }
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
898
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
899 /* Generate and emit a static constructor or destructor. WHICH must
131
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
900 be one of 'I' (for a constructor) or 'D' (for a destructor).
84e7813d76e9 gcc-8.2
mir3636
parents: 111
diff changeset
901 BODY is a STATEMENT_LIST containing GENERIC
111
kono
parents: 67
diff changeset
902 statements. PRIORITY is the initialization priority for this
kono
parents: 67
diff changeset
903 constructor or destructor. */
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
904
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
905 void
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
906 cgraph_build_static_cdtor (char which, tree body, int priority)
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
907 {
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
908 cgraph_build_static_cdtor_1 (which, body, priority, false);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
909 }
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
910
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
911 /* When target does not have ctors and dtors, we call all constructor
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
912 and destructor by special initialization/destruction function
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
913 recognized by collect2.
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
914
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
915 When we are going to build this function, collect all constructors and
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
916 destructors and turn them into normal functions. */
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
917
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
918 static void
111
kono
parents: 67
diff changeset
919 record_cdtor_fn (struct cgraph_node *node, vec<tree> *ctors, vec<tree> *dtors)
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
920 {
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
921 if (DECL_STATIC_CONSTRUCTOR (node->decl))
111
kono
parents: 67
diff changeset
922 ctors->safe_push (node->decl);
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
923 if (DECL_STATIC_DESTRUCTOR (node->decl))
111
kono
parents: 67
diff changeset
924 dtors->safe_push (node->decl);
kono
parents: 67
diff changeset
925 node = cgraph_node::get (node->decl);
kono
parents: 67
diff changeset
926 DECL_DISREGARD_INLINE_LIMITS (node->decl) = 1;
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
927 }
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
928
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
929 /* Define global constructors/destructor functions for the CDTORS, of
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
930 which they are LEN. The CDTORS are sorted by initialization
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
931 priority. If CTOR_P is true, these are constructors; otherwise,
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
932 they are destructors. */
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
933
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
934 static void
111
kono
parents: 67
diff changeset
935 build_cdtor (bool ctor_p, const vec<tree> &cdtors)
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
936 {
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
937 size_t i,j;
111
kono
parents: 67
diff changeset
938 size_t len = cdtors.length ();
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
939
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
940 i = 0;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
941 while (i < len)
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
942 {
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
943 tree body;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
944 tree fn;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
945 priority_type priority;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
946
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
947 priority = 0;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
948 body = NULL_TREE;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
949 j = i;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
950 do
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
951 {
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
952 priority_type p;
111
kono
parents: 67
diff changeset
953 fn = cdtors[j];
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
954 p = ctor_p ? DECL_INIT_PRIORITY (fn) : DECL_FINI_PRIORITY (fn);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
955 if (j == i)
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
956 priority = p;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
957 else if (p != priority)
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
958 break;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
959 j++;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
960 }
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
961 while (j < len);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
962
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
963 /* When there is only one cdtor and target supports them, do nothing. */
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
964 if (j == i + 1
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
965 && targetm.have_ctors_dtors)
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
966 {
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
967 i++;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
968 continue;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
969 }
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
970 /* Find the next batch of constructors/destructors with the same
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
971 initialization priority. */
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
972 for (;i < j; i++)
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
973 {
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
974 tree call;
111
kono
parents: 67
diff changeset
975 fn = cdtors[i];
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
976 call = build_call_expr (fn, 0);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
977 if (ctor_p)
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
978 DECL_STATIC_CONSTRUCTOR (fn) = 0;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
979 else
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
980 DECL_STATIC_DESTRUCTOR (fn) = 0;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
981 /* We do not want to optimize away pure/const calls here.
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
982 When optimizing, these should be already removed, when not
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
983 optimizing, we want user to be able to breakpoint in them. */
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
984 TREE_SIDE_EFFECTS (call) = 1;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
985 append_to_statement_list (call, &body);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
986 }
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
987 gcc_assert (body != NULL_TREE);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
988 /* Generate a function to call all the function of like
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
989 priority. */
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
990 cgraph_build_static_cdtor_1 (ctor_p ? 'I' : 'D', body, priority, true);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
991 }
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
992 }
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
993
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
994 /* Comparison function for qsort. P1 and P2 are actually of type
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
995 "tree *" and point to static constructors. DECL_INIT_PRIORITY is
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
996 used to determine the sort order. */
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
997
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
998 static int
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
999 compare_ctor (const void *p1, const void *p2)
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1000 {
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1001 tree f1;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1002 tree f2;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1003 int priority1;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1004 int priority2;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1005
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1006 f1 = *(const tree *)p1;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1007 f2 = *(const tree *)p2;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1008 priority1 = DECL_INIT_PRIORITY (f1);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1009 priority2 = DECL_INIT_PRIORITY (f2);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1010
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1011 if (priority1 < priority2)
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1012 return -1;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1013 else if (priority1 > priority2)
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1014 return 1;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1015 else
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1016 /* Ensure a stable sort. Constructors are executed in backwarding
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1017 order to make LTO initialize braries first. */
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1018 return DECL_UID (f2) - DECL_UID (f1);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1019 }
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1020
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1021 /* Comparison function for qsort. P1 and P2 are actually of type
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1022 "tree *" and point to static destructors. DECL_FINI_PRIORITY is
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1023 used to determine the sort order. */
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1024
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1025 static int
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1026 compare_dtor (const void *p1, const void *p2)
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1027 {
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1028 tree f1;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1029 tree f2;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1030 int priority1;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1031 int priority2;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1032
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1033 f1 = *(const tree *)p1;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1034 f2 = *(const tree *)p2;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1035 priority1 = DECL_FINI_PRIORITY (f1);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1036 priority2 = DECL_FINI_PRIORITY (f2);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1037
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1038 if (priority1 < priority2)
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1039 return -1;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1040 else if (priority1 > priority2)
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1041 return 1;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1042 else
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1043 /* Ensure a stable sort. */
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1044 return DECL_UID (f1) - DECL_UID (f2);
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1045 }
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1046
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1047 /* Generate functions to call static constructors and destructors
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1048 for targets that do not support .ctors/.dtors sections. These
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1049 functions have magic names which are detected by collect2. */
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1050
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1051 static void
111
kono
parents: 67
diff changeset
1052 build_cdtor_fns (vec<tree> *ctors, vec<tree> *dtors)
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1053 {
111
kono
parents: 67
diff changeset
1054 if (!ctors->is_empty ())
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1055 {
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1056 gcc_assert (!targetm.have_ctors_dtors || in_lto_p);
111
kono
parents: 67
diff changeset
1057 ctors->qsort (compare_ctor);
kono
parents: 67
diff changeset
1058 build_cdtor (/*ctor_p=*/true, *ctors);
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1059 }
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1060
111
kono
parents: 67
diff changeset
1061 if (!dtors->is_empty ())
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1062 {
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1063 gcc_assert (!targetm.have_ctors_dtors || in_lto_p);
111
kono
parents: 67
diff changeset
1064 dtors->qsort (compare_dtor);
kono
parents: 67
diff changeset
1065 build_cdtor (/*ctor_p=*/false, *dtors);
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1066 }
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1067 }
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1068
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1069 /* Look for constructors and destructors and produce function calling them.
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1070 This is needed for targets not supporting ctors or dtors, but we perform the
111
kono
parents: 67
diff changeset
1071 transformation also at linktime to merge possibly numerous
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1072 constructors/destructors into single function to improve code locality and
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1073 reduce size. */
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1074
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1075 static unsigned int
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1076 ipa_cdtor_merge (void)
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1077 {
111
kono
parents: 67
diff changeset
1078 /* A vector of FUNCTION_DECLs declared as static constructors. */
kono
parents: 67
diff changeset
1079 auto_vec<tree, 20> ctors;
kono
parents: 67
diff changeset
1080 /* A vector of FUNCTION_DECLs declared as static destructors. */
kono
parents: 67
diff changeset
1081 auto_vec<tree, 20> dtors;
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1082 struct cgraph_node *node;
111
kono
parents: 67
diff changeset
1083 FOR_EACH_DEFINED_FUNCTION (node)
kono
parents: 67
diff changeset
1084 if (DECL_STATIC_CONSTRUCTOR (node->decl)
kono
parents: 67
diff changeset
1085 || DECL_STATIC_DESTRUCTOR (node->decl))
kono
parents: 67
diff changeset
1086 record_cdtor_fn (node, &ctors, &dtors);
kono
parents: 67
diff changeset
1087 build_cdtor_fns (&ctors, &dtors);
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1088 return 0;
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1089 }
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1090
111
kono
parents: 67
diff changeset
1091 namespace {
kono
parents: 67
diff changeset
1092
kono
parents: 67
diff changeset
1093 const pass_data pass_data_ipa_cdtor_merge =
kono
parents: 67
diff changeset
1094 {
kono
parents: 67
diff changeset
1095 IPA_PASS, /* type */
kono
parents: 67
diff changeset
1096 "cdtor", /* name */
kono
parents: 67
diff changeset
1097 OPTGROUP_NONE, /* optinfo_flags */
kono
parents: 67
diff changeset
1098 TV_CGRAPHOPT, /* tv_id */
kono
parents: 67
diff changeset
1099 0, /* properties_required */
kono
parents: 67
diff changeset
1100 0, /* properties_provided */
kono
parents: 67
diff changeset
1101 0, /* properties_destroyed */
kono
parents: 67
diff changeset
1102 0, /* todo_flags_start */
kono
parents: 67
diff changeset
1103 0, /* todo_flags_finish */
kono
parents: 67
diff changeset
1104 };
kono
parents: 67
diff changeset
1105
kono
parents: 67
diff changeset
1106 class pass_ipa_cdtor_merge : public ipa_opt_pass_d
kono
parents: 67
diff changeset
1107 {
kono
parents: 67
diff changeset
1108 public:
kono
parents: 67
diff changeset
1109 pass_ipa_cdtor_merge (gcc::context *ctxt)
kono
parents: 67
diff changeset
1110 : ipa_opt_pass_d (pass_data_ipa_cdtor_merge, ctxt,
kono
parents: 67
diff changeset
1111 NULL, /* generate_summary */
kono
parents: 67
diff changeset
1112 NULL, /* write_summary */
kono
parents: 67
diff changeset
1113 NULL, /* read_summary */
kono
parents: 67
diff changeset
1114 NULL, /* write_optimization_summary */
kono
parents: 67
diff changeset
1115 NULL, /* read_optimization_summary */
kono
parents: 67
diff changeset
1116 NULL, /* stmt_fixup */
kono
parents: 67
diff changeset
1117 0, /* function_transform_todo_flags_start */
kono
parents: 67
diff changeset
1118 NULL, /* function_transform */
kono
parents: 67
diff changeset
1119 NULL) /* variable_transform */
kono
parents: 67
diff changeset
1120 {}
kono
parents: 67
diff changeset
1121
kono
parents: 67
diff changeset
1122 /* opt_pass methods: */
kono
parents: 67
diff changeset
1123 virtual bool gate (function *);
kono
parents: 67
diff changeset
1124 virtual unsigned int execute (function *) { return ipa_cdtor_merge (); }
kono
parents: 67
diff changeset
1125
kono
parents: 67
diff changeset
1126 }; // class pass_ipa_cdtor_merge
kono
parents: 67
diff changeset
1127
kono
parents: 67
diff changeset
1128 bool
kono
parents: 67
diff changeset
1129 pass_ipa_cdtor_merge::gate (function *)
kono
parents: 67
diff changeset
1130 {
kono
parents: 67
diff changeset
1131 /* Perform the pass when we have no ctors/dtors support
kono
parents: 67
diff changeset
1132 or at LTO time to merge multiple constructors into single
kono
parents: 67
diff changeset
1133 function. */
kono
parents: 67
diff changeset
1134 return !targetm.have_ctors_dtors || in_lto_p;
kono
parents: 67
diff changeset
1135 }
kono
parents: 67
diff changeset
1136
kono
parents: 67
diff changeset
1137 } // anon namespace
kono
parents: 67
diff changeset
1138
kono
parents: 67
diff changeset
1139 ipa_opt_pass_d *
kono
parents: 67
diff changeset
1140 make_pass_ipa_cdtor_merge (gcc::context *ctxt)
kono
parents: 67
diff changeset
1141 {
kono
parents: 67
diff changeset
1142 return new pass_ipa_cdtor_merge (ctxt);
kono
parents: 67
diff changeset
1143 }
kono
parents: 67
diff changeset
1144
kono
parents: 67
diff changeset
1145 /* Invalid pointer representing BOTTOM for single user dataflow. */
kono
parents: 67
diff changeset
1146 #define BOTTOM ((cgraph_node *)(size_t) 2)
kono
parents: 67
diff changeset
1147
kono
parents: 67
diff changeset
1148 /* Meet operation for single user dataflow.
kono
parents: 67
diff changeset
1149 Here we want to associate variables with sigle function that may access it.
kono
parents: 67
diff changeset
1150
kono
parents: 67
diff changeset
1151 FUNCTION is current single user of a variable, VAR is variable that uses it.
kono
parents: 67
diff changeset
1152 Latttice is stored in SINGLE_USER_MAP.
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1153
111
kono
parents: 67
diff changeset
1154 We represent:
kono
parents: 67
diff changeset
1155 - TOP by no entry in SIGNLE_USER_MAP
kono
parents: 67
diff changeset
1156 - BOTTOM by BOTTOM in AUX pointer (to save lookups)
kono
parents: 67
diff changeset
1157 - known single user by cgraph pointer in SINGLE_USER_MAP. */
kono
parents: 67
diff changeset
1158
kono
parents: 67
diff changeset
1159 cgraph_node *
kono
parents: 67
diff changeset
1160 meet (cgraph_node *function, varpool_node *var,
kono
parents: 67
diff changeset
1161 hash_map<varpool_node *, cgraph_node *> &single_user_map)
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1162 {
111
kono
parents: 67
diff changeset
1163 struct cgraph_node *user, **f;
kono
parents: 67
diff changeset
1164
kono
parents: 67
diff changeset
1165 if (var->aux == BOTTOM)
kono
parents: 67
diff changeset
1166 return BOTTOM;
kono
parents: 67
diff changeset
1167
kono
parents: 67
diff changeset
1168 f = single_user_map.get (var);
kono
parents: 67
diff changeset
1169 if (!f)
kono
parents: 67
diff changeset
1170 return function;
kono
parents: 67
diff changeset
1171 user = *f;
kono
parents: 67
diff changeset
1172 if (!function)
kono
parents: 67
diff changeset
1173 return user;
kono
parents: 67
diff changeset
1174 else if (function != user)
kono
parents: 67
diff changeset
1175 return BOTTOM;
kono
parents: 67
diff changeset
1176 else
kono
parents: 67
diff changeset
1177 return function;
kono
parents: 67
diff changeset
1178 }
kono
parents: 67
diff changeset
1179
kono
parents: 67
diff changeset
1180 /* Propagation step of single-use dataflow.
kono
parents: 67
diff changeset
1181
kono
parents: 67
diff changeset
1182 Check all uses of VNODE and see if they are used by single function FUNCTION.
kono
parents: 67
diff changeset
1183 SINGLE_USER_MAP represents the dataflow lattice. */
kono
parents: 67
diff changeset
1184
kono
parents: 67
diff changeset
1185 cgraph_node *
kono
parents: 67
diff changeset
1186 propagate_single_user (varpool_node *vnode, cgraph_node *function,
kono
parents: 67
diff changeset
1187 hash_map<varpool_node *, cgraph_node *> &single_user_map)
kono
parents: 67
diff changeset
1188 {
kono
parents: 67
diff changeset
1189 int i;
kono
parents: 67
diff changeset
1190 struct ipa_ref *ref;
kono
parents: 67
diff changeset
1191
kono
parents: 67
diff changeset
1192 gcc_assert (!vnode->externally_visible);
kono
parents: 67
diff changeset
1193
kono
parents: 67
diff changeset
1194 /* If node is an alias, first meet with its target. */
kono
parents: 67
diff changeset
1195 if (vnode->alias)
kono
parents: 67
diff changeset
1196 function = meet (function, vnode->get_alias_target (), single_user_map);
kono
parents: 67
diff changeset
1197
kono
parents: 67
diff changeset
1198 /* Check all users and see if they correspond to a single function. */
kono
parents: 67
diff changeset
1199 for (i = 0; vnode->iterate_referring (i, ref) && function != BOTTOM; i++)
kono
parents: 67
diff changeset
1200 {
kono
parents: 67
diff changeset
1201 struct cgraph_node *cnode = dyn_cast <cgraph_node *> (ref->referring);
kono
parents: 67
diff changeset
1202 if (cnode)
kono
parents: 67
diff changeset
1203 {
kono
parents: 67
diff changeset
1204 if (cnode->global.inlined_to)
kono
parents: 67
diff changeset
1205 cnode = cnode->global.inlined_to;
kono
parents: 67
diff changeset
1206 if (!function)
kono
parents: 67
diff changeset
1207 function = cnode;
kono
parents: 67
diff changeset
1208 else if (function != cnode)
kono
parents: 67
diff changeset
1209 function = BOTTOM;
kono
parents: 67
diff changeset
1210 }
kono
parents: 67
diff changeset
1211 else
kono
parents: 67
diff changeset
1212 function = meet (function, dyn_cast <varpool_node *> (ref->referring),
kono
parents: 67
diff changeset
1213 single_user_map);
kono
parents: 67
diff changeset
1214 }
kono
parents: 67
diff changeset
1215 return function;
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1216 }
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1217
111
kono
parents: 67
diff changeset
1218 /* Pass setting used_by_single_function flag.
kono
parents: 67
diff changeset
1219 This flag is set on variable when there is only one function that may
kono
parents: 67
diff changeset
1220 possibly referr to it. */
kono
parents: 67
diff changeset
1221
kono
parents: 67
diff changeset
1222 static unsigned int
kono
parents: 67
diff changeset
1223 ipa_single_use (void)
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1224 {
111
kono
parents: 67
diff changeset
1225 varpool_node *first = (varpool_node *) (void *) 1;
kono
parents: 67
diff changeset
1226 varpool_node *var;
kono
parents: 67
diff changeset
1227 hash_map<varpool_node *, cgraph_node *> single_user_map;
kono
parents: 67
diff changeset
1228
kono
parents: 67
diff changeset
1229 FOR_EACH_DEFINED_VARIABLE (var)
kono
parents: 67
diff changeset
1230 if (!var->all_refs_explicit_p ())
kono
parents: 67
diff changeset
1231 var->aux = BOTTOM;
kono
parents: 67
diff changeset
1232 else
kono
parents: 67
diff changeset
1233 {
kono
parents: 67
diff changeset
1234 /* Enqueue symbol for dataflow. */
kono
parents: 67
diff changeset
1235 var->aux = first;
kono
parents: 67
diff changeset
1236 first = var;
kono
parents: 67
diff changeset
1237 }
kono
parents: 67
diff changeset
1238
kono
parents: 67
diff changeset
1239 /* The actual dataflow. */
kono
parents: 67
diff changeset
1240
kono
parents: 67
diff changeset
1241 while (first != (void *) 1)
kono
parents: 67
diff changeset
1242 {
kono
parents: 67
diff changeset
1243 cgraph_node *user, *orig_user, **f;
kono
parents: 67
diff changeset
1244
kono
parents: 67
diff changeset
1245 var = first;
kono
parents: 67
diff changeset
1246 first = (varpool_node *)first->aux;
kono
parents: 67
diff changeset
1247
kono
parents: 67
diff changeset
1248 f = single_user_map.get (var);
kono
parents: 67
diff changeset
1249 if (f)
kono
parents: 67
diff changeset
1250 orig_user = *f;
kono
parents: 67
diff changeset
1251 else
kono
parents: 67
diff changeset
1252 orig_user = NULL;
kono
parents: 67
diff changeset
1253 user = propagate_single_user (var, orig_user, single_user_map);
kono
parents: 67
diff changeset
1254
kono
parents: 67
diff changeset
1255 gcc_checking_assert (var->aux != BOTTOM);
kono
parents: 67
diff changeset
1256
kono
parents: 67
diff changeset
1257 /* If user differs, enqueue all references. */
kono
parents: 67
diff changeset
1258 if (user != orig_user)
kono
parents: 67
diff changeset
1259 {
kono
parents: 67
diff changeset
1260 unsigned int i;
kono
parents: 67
diff changeset
1261 ipa_ref *ref;
kono
parents: 67
diff changeset
1262
kono
parents: 67
diff changeset
1263 single_user_map.put (var, user);
kono
parents: 67
diff changeset
1264
kono
parents: 67
diff changeset
1265 /* Enqueue all aliases for re-processing. */
kono
parents: 67
diff changeset
1266 for (i = 0; var->iterate_direct_aliases (i, ref); i++)
kono
parents: 67
diff changeset
1267 if (!ref->referring->aux)
kono
parents: 67
diff changeset
1268 {
kono
parents: 67
diff changeset
1269 ref->referring->aux = first;
kono
parents: 67
diff changeset
1270 first = dyn_cast <varpool_node *> (ref->referring);
kono
parents: 67
diff changeset
1271 }
kono
parents: 67
diff changeset
1272 /* Enqueue all users for re-processing. */
kono
parents: 67
diff changeset
1273 for (i = 0; var->iterate_reference (i, ref); i++)
kono
parents: 67
diff changeset
1274 if (!ref->referred->aux
kono
parents: 67
diff changeset
1275 && ref->referred->definition
kono
parents: 67
diff changeset
1276 && is_a <varpool_node *> (ref->referred))
kono
parents: 67
diff changeset
1277 {
kono
parents: 67
diff changeset
1278 ref->referred->aux = first;
kono
parents: 67
diff changeset
1279 first = dyn_cast <varpool_node *> (ref->referred);
kono
parents: 67
diff changeset
1280 }
kono
parents: 67
diff changeset
1281
kono
parents: 67
diff changeset
1282 /* If user is BOTTOM, just punt on this var. */
kono
parents: 67
diff changeset
1283 if (user == BOTTOM)
kono
parents: 67
diff changeset
1284 var->aux = BOTTOM;
kono
parents: 67
diff changeset
1285 else
kono
parents: 67
diff changeset
1286 var->aux = NULL;
kono
parents: 67
diff changeset
1287 }
kono
parents: 67
diff changeset
1288 else
kono
parents: 67
diff changeset
1289 var->aux = NULL;
kono
parents: 67
diff changeset
1290 }
kono
parents: 67
diff changeset
1291
kono
parents: 67
diff changeset
1292 FOR_EACH_DEFINED_VARIABLE (var)
kono
parents: 67
diff changeset
1293 {
kono
parents: 67
diff changeset
1294 if (var->aux != BOTTOM)
kono
parents: 67
diff changeset
1295 {
kono
parents: 67
diff changeset
1296 /* Not having the single user known means that the VAR is
kono
parents: 67
diff changeset
1297 unreachable. Either someone forgot to remove unreachable
kono
parents: 67
diff changeset
1298 variables or the reachability here is wrong. */
kono
parents: 67
diff changeset
1299
kono
parents: 67
diff changeset
1300 gcc_checking_assert (single_user_map.get (var));
kono
parents: 67
diff changeset
1301
kono
parents: 67
diff changeset
1302 if (dump_file)
kono
parents: 67
diff changeset
1303 {
kono
parents: 67
diff changeset
1304 fprintf (dump_file, "Variable %s is used by single function\n",
kono
parents: 67
diff changeset
1305 var->dump_name ());
kono
parents: 67
diff changeset
1306 }
kono
parents: 67
diff changeset
1307 var->used_by_single_function = true;
kono
parents: 67
diff changeset
1308 }
kono
parents: 67
diff changeset
1309 var->aux = NULL;
kono
parents: 67
diff changeset
1310 }
kono
parents: 67
diff changeset
1311 return 0;
kono
parents: 67
diff changeset
1312 }
kono
parents: 67
diff changeset
1313
kono
parents: 67
diff changeset
1314 namespace {
kono
parents: 67
diff changeset
1315
kono
parents: 67
diff changeset
1316 const pass_data pass_data_ipa_single_use =
kono
parents: 67
diff changeset
1317 {
kono
parents: 67
diff changeset
1318 IPA_PASS, /* type */
kono
parents: 67
diff changeset
1319 "single-use", /* name */
kono
parents: 67
diff changeset
1320 OPTGROUP_NONE, /* optinfo_flags */
kono
parents: 67
diff changeset
1321 TV_CGRAPHOPT, /* tv_id */
kono
parents: 67
diff changeset
1322 0, /* properties_required */
kono
parents: 67
diff changeset
1323 0, /* properties_provided */
kono
parents: 67
diff changeset
1324 0, /* properties_destroyed */
kono
parents: 67
diff changeset
1325 0, /* todo_flags_start */
kono
parents: 67
diff changeset
1326 0, /* todo_flags_finish */
67
f6334be47118 update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents: 63
diff changeset
1327 };
111
kono
parents: 67
diff changeset
1328
kono
parents: 67
diff changeset
1329 class pass_ipa_single_use : public ipa_opt_pass_d
kono
parents: 67
diff changeset
1330 {
kono
parents: 67
diff changeset
1331 public:
kono
parents: 67
diff changeset
1332 pass_ipa_single_use (gcc::context *ctxt)
kono
parents: 67
diff changeset
1333 : ipa_opt_pass_d (pass_data_ipa_single_use, ctxt,
kono
parents: 67
diff changeset
1334 NULL, /* generate_summary */
kono
parents: 67
diff changeset
1335 NULL, /* write_summary */
kono
parents: 67
diff changeset
1336 NULL, /* read_summary */
kono
parents: 67
diff changeset
1337 NULL, /* write_optimization_summary */
kono
parents: 67
diff changeset
1338 NULL, /* read_optimization_summary */
kono
parents: 67
diff changeset
1339 NULL, /* stmt_fixup */
kono
parents: 67
diff changeset
1340 0, /* function_transform_todo_flags_start */
kono
parents: 67
diff changeset
1341 NULL, /* function_transform */
kono
parents: 67
diff changeset
1342 NULL) /* variable_transform */
kono
parents: 67
diff changeset
1343 {}
kono
parents: 67
diff changeset
1344
kono
parents: 67
diff changeset
1345 /* opt_pass methods: */
kono
parents: 67
diff changeset
1346 virtual unsigned int execute (function *) { return ipa_single_use (); }
kono
parents: 67
diff changeset
1347
kono
parents: 67
diff changeset
1348 }; // class pass_ipa_single_use
kono
parents: 67
diff changeset
1349
kono
parents: 67
diff changeset
1350 } // anon namespace
kono
parents: 67
diff changeset
1351
kono
parents: 67
diff changeset
1352 ipa_opt_pass_d *
kono
parents: 67
diff changeset
1353 make_pass_ipa_single_use (gcc::context *ctxt)
kono
parents: 67
diff changeset
1354 {
kono
parents: 67
diff changeset
1355 return new pass_ipa_single_use (ctxt);
kono
parents: 67
diff changeset
1356 }
kono
parents: 67
diff changeset
1357
kono
parents: 67
diff changeset
1358 /* Materialize all clones. */
kono
parents: 67
diff changeset
1359
kono
parents: 67
diff changeset
1360 namespace {
kono
parents: 67
diff changeset
1361
kono
parents: 67
diff changeset
1362 const pass_data pass_data_materialize_all_clones =
kono
parents: 67
diff changeset
1363 {
kono
parents: 67
diff changeset
1364 SIMPLE_IPA_PASS, /* type */
kono
parents: 67
diff changeset
1365 "materialize-all-clones", /* name */
kono
parents: 67
diff changeset
1366 OPTGROUP_NONE, /* optinfo_flags */
kono
parents: 67
diff changeset
1367 TV_IPA_OPT, /* tv_id */
kono
parents: 67
diff changeset
1368 0, /* properties_required */
kono
parents: 67
diff changeset
1369 0, /* properties_provided */
kono
parents: 67
diff changeset
1370 0, /* properties_destroyed */
kono
parents: 67
diff changeset
1371 0, /* todo_flags_start */
kono
parents: 67
diff changeset
1372 0, /* todo_flags_finish */
kono
parents: 67
diff changeset
1373 };
kono
parents: 67
diff changeset
1374
kono
parents: 67
diff changeset
1375 class pass_materialize_all_clones : public simple_ipa_opt_pass
kono
parents: 67
diff changeset
1376 {
kono
parents: 67
diff changeset
1377 public:
kono
parents: 67
diff changeset
1378 pass_materialize_all_clones (gcc::context *ctxt)
kono
parents: 67
diff changeset
1379 : simple_ipa_opt_pass (pass_data_materialize_all_clones, ctxt)
kono
parents: 67
diff changeset
1380 {}
kono
parents: 67
diff changeset
1381
kono
parents: 67
diff changeset
1382 /* opt_pass methods: */
kono
parents: 67
diff changeset
1383 virtual unsigned int execute (function *)
kono
parents: 67
diff changeset
1384 {
kono
parents: 67
diff changeset
1385 symtab->materialize_all_clones ();
kono
parents: 67
diff changeset
1386 return 0;
kono
parents: 67
diff changeset
1387 }
kono
parents: 67
diff changeset
1388
kono
parents: 67
diff changeset
1389 }; // class pass_materialize_all_clones
kono
parents: 67
diff changeset
1390
kono
parents: 67
diff changeset
1391 } // anon namespace
kono
parents: 67
diff changeset
1392
kono
parents: 67
diff changeset
1393 simple_ipa_opt_pass *
kono
parents: 67
diff changeset
1394 make_pass_materialize_all_clones (gcc::context *ctxt)
kono
parents: 67
diff changeset
1395 {
kono
parents: 67
diff changeset
1396 return new pass_materialize_all_clones (ctxt);
kono
parents: 67
diff changeset
1397 }