1 |
12 |
jlechner |
/* Perform the semantic phase of parsing, i.e., the process of
|
2 |
|
|
building tree structure, checking semantic consistency, and
|
3 |
|
|
building RTL. These routines are used both during actual parsing
|
4 |
|
|
and during the instantiation of template functions.
|
5 |
|
|
|
6 |
|
|
Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
|
7 |
|
|
Free Software Foundation, Inc.
|
8 |
|
|
Written by Mark Mitchell (mmitchell@usa.net) based on code found
|
9 |
|
|
formerly in parse.y and pt.c.
|
10 |
|
|
|
11 |
|
|
This file is part of GCC.
|
12 |
|
|
|
13 |
|
|
GCC is free software; you can redistribute it and/or modify it
|
14 |
|
|
under the terms of the GNU General Public License as published by
|
15 |
|
|
the Free Software Foundation; either version 2, or (at your option)
|
16 |
|
|
any later version.
|
17 |
|
|
|
18 |
|
|
GCC is distributed in the hope that it will be useful, but
|
19 |
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
20 |
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
21 |
|
|
General Public License for more details.
|
22 |
|
|
|
23 |
|
|
You should have received a copy of the GNU General Public License
|
24 |
|
|
along with GCC; see the file COPYING. If not, write to the Free
|
25 |
|
|
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
|
26 |
|
|
02110-1301, USA. */
|
27 |
|
|
|
28 |
|
|
#include "config.h"
|
29 |
|
|
#include "system.h"
|
30 |
|
|
#include "coretypes.h"
|
31 |
|
|
#include "tm.h"
|
32 |
|
|
#include "tree.h"
|
33 |
|
|
#include "cp-tree.h"
|
34 |
|
|
#include "c-common.h"
|
35 |
|
|
#include "tree-inline.h"
|
36 |
|
|
#include "tree-mudflap.h"
|
37 |
|
|
#include "except.h"
|
38 |
|
|
#include "toplev.h"
|
39 |
|
|
#include "flags.h"
|
40 |
|
|
#include "rtl.h"
|
41 |
|
|
#include "expr.h"
|
42 |
|
|
#include "output.h"
|
43 |
|
|
#include "timevar.h"
|
44 |
|
|
#include "debug.h"
|
45 |
|
|
#include "diagnostic.h"
|
46 |
|
|
#include "cgraph.h"
|
47 |
|
|
#include "tree-iterator.h"
|
48 |
|
|
#include "vec.h"
|
49 |
|
|
#include "target.h"
|
50 |
|
|
|
51 |
|
|
/* There routines provide a modular interface to perform many parsing
|
52 |
|
|
operations. They may therefore be used during actual parsing, or
|
53 |
|
|
during template instantiation, which may be regarded as a
|
54 |
|
|
degenerate form of parsing. Since the current g++ parser is
|
55 |
|
|
lacking in several respects, and will be reimplemented, we are
|
56 |
|
|
attempting to move most code that is not directly related to
|
57 |
|
|
parsing into this file; that will make implementing the new parser
|
58 |
|
|
much easier since it will be able to make use of these routines. */
|
59 |
|
|
|
60 |
|
|
static tree maybe_convert_cond (tree);
|
61 |
|
|
static tree simplify_aggr_init_exprs_r (tree *, int *, void *);
|
62 |
|
|
static void emit_associated_thunks (tree);
|
63 |
|
|
static tree finalize_nrv_r (tree *, int *, void *);
|
64 |
|
|
|
65 |
|
|
|
66 |
|
|
/* Deferred Access Checking Overview
|
67 |
|
|
---------------------------------
|
68 |
|
|
|
69 |
|
|
Most C++ expressions and declarations require access checking
|
70 |
|
|
to be performed during parsing. However, in several cases,
|
71 |
|
|
this has to be treated differently.
|
72 |
|
|
|
73 |
|
|
For member declarations, access checking has to be deferred
|
74 |
|
|
until more information about the declaration is known. For
|
75 |
|
|
example:
|
76 |
|
|
|
77 |
|
|
class A {
|
78 |
|
|
typedef int X;
|
79 |
|
|
public:
|
80 |
|
|
X f();
|
81 |
|
|
};
|
82 |
|
|
|
83 |
|
|
A::X A::f();
|
84 |
|
|
A::X g();
|
85 |
|
|
|
86 |
|
|
When we are parsing the function return type `A::X', we don't
|
87 |
|
|
really know if this is allowed until we parse the function name.
|
88 |
|
|
|
89 |
|
|
Furthermore, some contexts require that access checking is
|
90 |
|
|
never performed at all. These include class heads, and template
|
91 |
|
|
instantiations.
|
92 |
|
|
|
93 |
|
|
Typical use of access checking functions is described here:
|
94 |
|
|
|
95 |
|
|
1. When we enter a context that requires certain access checking
|
96 |
|
|
mode, the function `push_deferring_access_checks' is called with
|
97 |
|
|
DEFERRING argument specifying the desired mode. Access checking
|
98 |
|
|
may be performed immediately (dk_no_deferred), deferred
|
99 |
|
|
(dk_deferred), or not performed (dk_no_check).
|
100 |
|
|
|
101 |
|
|
2. When a declaration such as a type, or a variable, is encountered,
|
102 |
|
|
the function `perform_or_defer_access_check' is called. It
|
103 |
|
|
maintains a TREE_LIST of all deferred checks.
|
104 |
|
|
|
105 |
|
|
3. The global `current_class_type' or `current_function_decl' is then
|
106 |
|
|
setup by the parser. `enforce_access' relies on these information
|
107 |
|
|
to check access.
|
108 |
|
|
|
109 |
|
|
4. Upon exiting the context mentioned in step 1,
|
110 |
|
|
`perform_deferred_access_checks' is called to check all declaration
|
111 |
|
|
stored in the TREE_LIST. `pop_deferring_access_checks' is then
|
112 |
|
|
called to restore the previous access checking mode.
|
113 |
|
|
|
114 |
|
|
In case of parsing error, we simply call `pop_deferring_access_checks'
|
115 |
|
|
without `perform_deferred_access_checks'. */
|
116 |
|
|
|
117 |
|
|
typedef struct deferred_access GTY(())
|
118 |
|
|
{
|
119 |
|
|
/* A TREE_LIST representing name-lookups for which we have deferred
|
120 |
|
|
checking access controls. We cannot check the accessibility of
|
121 |
|
|
names used in a decl-specifier-seq until we know what is being
|
122 |
|
|
declared because code like:
|
123 |
|
|
|
124 |
|
|
class A {
|
125 |
|
|
class B {};
|
126 |
|
|
B* f();
|
127 |
|
|
}
|
128 |
|
|
|
129 |
|
|
A::B* A::f() { return 0; }
|
130 |
|
|
|
131 |
|
|
is valid, even though `A::B' is not generally accessible.
|
132 |
|
|
|
133 |
|
|
The TREE_PURPOSE of each node is the scope used to qualify the
|
134 |
|
|
name being looked up; the TREE_VALUE is the DECL to which the
|
135 |
|
|
name was resolved. */
|
136 |
|
|
tree deferred_access_checks;
|
137 |
|
|
|
138 |
|
|
/* The current mode of access checks. */
|
139 |
|
|
enum deferring_kind deferring_access_checks_kind;
|
140 |
|
|
|
141 |
|
|
} deferred_access;
|
142 |
|
|
DEF_VEC_O (deferred_access);
|
143 |
|
|
DEF_VEC_ALLOC_O (deferred_access,gc);
|
144 |
|
|
|
145 |
|
|
/* Data for deferred access checking. */
|
146 |
|
|
static GTY(()) VEC(deferred_access,gc) *deferred_access_stack;
|
147 |
|
|
static GTY(()) unsigned deferred_access_no_check;
|
148 |
|
|
|
149 |
|
|
/* Save the current deferred access states and start deferred
|
150 |
|
|
access checking iff DEFER_P is true. */
|
151 |
|
|
|
152 |
|
|
void
|
153 |
|
|
push_deferring_access_checks (deferring_kind deferring)
|
154 |
|
|
{
|
155 |
|
|
/* For context like template instantiation, access checking
|
156 |
|
|
disabling applies to all nested context. */
|
157 |
|
|
if (deferred_access_no_check || deferring == dk_no_check)
|
158 |
|
|
deferred_access_no_check++;
|
159 |
|
|
else
|
160 |
|
|
{
|
161 |
|
|
deferred_access *ptr;
|
162 |
|
|
|
163 |
|
|
ptr = VEC_safe_push (deferred_access, gc, deferred_access_stack, NULL);
|
164 |
|
|
ptr->deferred_access_checks = NULL_TREE;
|
165 |
|
|
ptr->deferring_access_checks_kind = deferring;
|
166 |
|
|
}
|
167 |
|
|
}
|
168 |
|
|
|
169 |
|
|
/* Resume deferring access checks again after we stopped doing
|
170 |
|
|
this previously. */
|
171 |
|
|
|
172 |
|
|
void
|
173 |
|
|
resume_deferring_access_checks (void)
|
174 |
|
|
{
|
175 |
|
|
if (!deferred_access_no_check)
|
176 |
|
|
VEC_last (deferred_access, deferred_access_stack)
|
177 |
|
|
->deferring_access_checks_kind = dk_deferred;
|
178 |
|
|
}
|
179 |
|
|
|
180 |
|
|
/* Stop deferring access checks. */
|
181 |
|
|
|
182 |
|
|
void
|
183 |
|
|
stop_deferring_access_checks (void)
|
184 |
|
|
{
|
185 |
|
|
if (!deferred_access_no_check)
|
186 |
|
|
VEC_last (deferred_access, deferred_access_stack)
|
187 |
|
|
->deferring_access_checks_kind = dk_no_deferred;
|
188 |
|
|
}
|
189 |
|
|
|
190 |
|
|
/* Discard the current deferred access checks and restore the
|
191 |
|
|
previous states. */
|
192 |
|
|
|
193 |
|
|
void
|
194 |
|
|
pop_deferring_access_checks (void)
|
195 |
|
|
{
|
196 |
|
|
if (deferred_access_no_check)
|
197 |
|
|
deferred_access_no_check--;
|
198 |
|
|
else
|
199 |
|
|
VEC_pop (deferred_access, deferred_access_stack);
|
200 |
|
|
}
|
201 |
|
|
|
202 |
|
|
/* Returns a TREE_LIST representing the deferred checks.
|
203 |
|
|
The TREE_PURPOSE of each node is the type through which the
|
204 |
|
|
access occurred; the TREE_VALUE is the declaration named.
|
205 |
|
|
*/
|
206 |
|
|
|
207 |
|
|
tree
|
208 |
|
|
get_deferred_access_checks (void)
|
209 |
|
|
{
|
210 |
|
|
if (deferred_access_no_check)
|
211 |
|
|
return NULL;
|
212 |
|
|
else
|
213 |
|
|
return (VEC_last (deferred_access, deferred_access_stack)
|
214 |
|
|
->deferred_access_checks);
|
215 |
|
|
}
|
216 |
|
|
|
217 |
|
|
/* Take current deferred checks and combine with the
|
218 |
|
|
previous states if we also defer checks previously.
|
219 |
|
|
Otherwise perform checks now. */
|
220 |
|
|
|
221 |
|
|
void
|
222 |
|
|
pop_to_parent_deferring_access_checks (void)
|
223 |
|
|
{
|
224 |
|
|
if (deferred_access_no_check)
|
225 |
|
|
deferred_access_no_check--;
|
226 |
|
|
else
|
227 |
|
|
{
|
228 |
|
|
tree checks;
|
229 |
|
|
deferred_access *ptr;
|
230 |
|
|
|
231 |
|
|
checks = (VEC_last (deferred_access, deferred_access_stack)
|
232 |
|
|
->deferred_access_checks);
|
233 |
|
|
|
234 |
|
|
VEC_pop (deferred_access, deferred_access_stack);
|
235 |
|
|
ptr = VEC_last (deferred_access, deferred_access_stack);
|
236 |
|
|
if (ptr->deferring_access_checks_kind == dk_no_deferred)
|
237 |
|
|
{
|
238 |
|
|
/* Check access. */
|
239 |
|
|
for (; checks; checks = TREE_CHAIN (checks))
|
240 |
|
|
enforce_access (TREE_PURPOSE (checks),
|
241 |
|
|
TREE_VALUE (checks));
|
242 |
|
|
}
|
243 |
|
|
else
|
244 |
|
|
{
|
245 |
|
|
/* Merge with parent. */
|
246 |
|
|
tree next;
|
247 |
|
|
tree original = ptr->deferred_access_checks;
|
248 |
|
|
|
249 |
|
|
for (; checks; checks = next)
|
250 |
|
|
{
|
251 |
|
|
tree probe;
|
252 |
|
|
|
253 |
|
|
next = TREE_CHAIN (checks);
|
254 |
|
|
|
255 |
|
|
for (probe = original; probe; probe = TREE_CHAIN (probe))
|
256 |
|
|
if (TREE_VALUE (probe) == TREE_VALUE (checks)
|
257 |
|
|
&& TREE_PURPOSE (probe) == TREE_PURPOSE (checks))
|
258 |
|
|
goto found;
|
259 |
|
|
/* Insert into parent's checks. */
|
260 |
|
|
TREE_CHAIN (checks) = ptr->deferred_access_checks;
|
261 |
|
|
ptr->deferred_access_checks = checks;
|
262 |
|
|
found:;
|
263 |
|
|
}
|
264 |
|
|
}
|
265 |
|
|
}
|
266 |
|
|
}
|
267 |
|
|
|
268 |
|
|
/* Perform the access checks in CHECKS. The TREE_PURPOSE of each node
|
269 |
|
|
is the BINFO indicating the qualifying scope used to access the
|
270 |
|
|
DECL node stored in the TREE_VALUE of the node. */
|
271 |
|
|
|
272 |
|
|
void
|
273 |
|
|
perform_access_checks (tree checks)
|
274 |
|
|
{
|
275 |
|
|
while (checks)
|
276 |
|
|
{
|
277 |
|
|
enforce_access (TREE_PURPOSE (checks),
|
278 |
|
|
TREE_VALUE (checks));
|
279 |
|
|
checks = TREE_CHAIN (checks);
|
280 |
|
|
}
|
281 |
|
|
}
|
282 |
|
|
|
283 |
|
|
/* Perform the deferred access checks.
|
284 |
|
|
|
285 |
|
|
After performing the checks, we still have to keep the list
|
286 |
|
|
`deferred_access_stack->deferred_access_checks' since we may want
|
287 |
|
|
to check access for them again later in a different context.
|
288 |
|
|
For example:
|
289 |
|
|
|
290 |
|
|
class A {
|
291 |
|
|
typedef int X;
|
292 |
|
|
static X a;
|
293 |
|
|
};
|
294 |
|
|
A::X A::a, x; // No error for `A::a', error for `x'
|
295 |
|
|
|
296 |
|
|
We have to perform deferred access of `A::X', first with `A::a',
|
297 |
|
|
next with `x'. */
|
298 |
|
|
|
299 |
|
|
void
|
300 |
|
|
perform_deferred_access_checks (void)
|
301 |
|
|
{
|
302 |
|
|
perform_access_checks (get_deferred_access_checks ());
|
303 |
|
|
}
|
304 |
|
|
|
305 |
|
|
/* Defer checking the accessibility of DECL, when looked up in
|
306 |
|
|
BINFO. */
|
307 |
|
|
|
308 |
|
|
void
|
309 |
|
|
perform_or_defer_access_check (tree binfo, tree decl)
|
310 |
|
|
{
|
311 |
|
|
tree check;
|
312 |
|
|
deferred_access *ptr;
|
313 |
|
|
|
314 |
|
|
/* Exit if we are in a context that no access checking is performed.
|
315 |
|
|
*/
|
316 |
|
|
if (deferred_access_no_check)
|
317 |
|
|
return;
|
318 |
|
|
|
319 |
|
|
gcc_assert (TREE_CODE (binfo) == TREE_BINFO);
|
320 |
|
|
|
321 |
|
|
ptr = VEC_last (deferred_access, deferred_access_stack);
|
322 |
|
|
|
323 |
|
|
/* If we are not supposed to defer access checks, just check now. */
|
324 |
|
|
if (ptr->deferring_access_checks_kind == dk_no_deferred)
|
325 |
|
|
{
|
326 |
|
|
enforce_access (binfo, decl);
|
327 |
|
|
return;
|
328 |
|
|
}
|
329 |
|
|
|
330 |
|
|
/* See if we are already going to perform this check. */
|
331 |
|
|
for (check = ptr->deferred_access_checks;
|
332 |
|
|
check;
|
333 |
|
|
check = TREE_CHAIN (check))
|
334 |
|
|
if (TREE_VALUE (check) == decl && TREE_PURPOSE (check) == binfo)
|
335 |
|
|
return;
|
336 |
|
|
/* If not, record the check. */
|
337 |
|
|
ptr->deferred_access_checks
|
338 |
|
|
= tree_cons (binfo, decl, ptr->deferred_access_checks);
|
339 |
|
|
}
|
340 |
|
|
|
341 |
|
|
/* Returns nonzero if the current statement is a full expression,
|
342 |
|
|
i.e. temporaries created during that statement should be destroyed
|
343 |
|
|
at the end of the statement. */
|
344 |
|
|
|
345 |
|
|
int
|
346 |
|
|
stmts_are_full_exprs_p (void)
|
347 |
|
|
{
|
348 |
|
|
return current_stmt_tree ()->stmts_are_full_exprs_p;
|
349 |
|
|
}
|
350 |
|
|
|
351 |
|
|
/* T is a statement. Add it to the statement-tree. This is the C++
|
352 |
|
|
version. The C/ObjC frontends have a slightly different version of
|
353 |
|
|
this function. */
|
354 |
|
|
|
355 |
|
|
tree
|
356 |
|
|
add_stmt (tree t)
|
357 |
|
|
{
|
358 |
|
|
enum tree_code code = TREE_CODE (t);
|
359 |
|
|
|
360 |
|
|
if (EXPR_P (t) && code != LABEL_EXPR)
|
361 |
|
|
{
|
362 |
|
|
if (!EXPR_HAS_LOCATION (t))
|
363 |
|
|
SET_EXPR_LOCATION (t, input_location);
|
364 |
|
|
|
365 |
|
|
/* When we expand a statement-tree, we must know whether or not the
|
366 |
|
|
statements are full-expressions. We record that fact here. */
|
367 |
|
|
STMT_IS_FULL_EXPR_P (t) = stmts_are_full_exprs_p ();
|
368 |
|
|
}
|
369 |
|
|
|
370 |
|
|
/* Add T to the statement-tree. Non-side-effect statements need to be
|
371 |
|
|
recorded during statement expressions. */
|
372 |
|
|
append_to_statement_list_force (t, &cur_stmt_list);
|
373 |
|
|
|
374 |
|
|
return t;
|
375 |
|
|
}
|
376 |
|
|
|
377 |
|
|
/* Returns the stmt_tree (if any) to which statements are currently
|
378 |
|
|
being added. If there is no active statement-tree, NULL is
|
379 |
|
|
returned. */
|
380 |
|
|
|
381 |
|
|
stmt_tree
|
382 |
|
|
current_stmt_tree (void)
|
383 |
|
|
{
|
384 |
|
|
return (cfun
|
385 |
|
|
? &cfun->language->base.x_stmt_tree
|
386 |
|
|
: &scope_chain->x_stmt_tree);
|
387 |
|
|
}
|
388 |
|
|
|
389 |
|
|
/* If statements are full expressions, wrap STMT in a CLEANUP_POINT_EXPR. */
|
390 |
|
|
|
391 |
|
|
static tree
|
392 |
|
|
maybe_cleanup_point_expr (tree expr)
|
393 |
|
|
{
|
394 |
|
|
if (!processing_template_decl && stmts_are_full_exprs_p ())
|
395 |
|
|
expr = fold_build_cleanup_point_expr (TREE_TYPE (expr), expr);
|
396 |
|
|
return expr;
|
397 |
|
|
}
|
398 |
|
|
|
399 |
|
|
/* Like maybe_cleanup_point_expr except have the type of the new expression be
|
400 |
|
|
void so we don't need to create a temporary variable to hold the inner
|
401 |
|
|
expression. The reason why we do this is because the original type might be
|
402 |
|
|
an aggregate and we cannot create a temporary variable for that type. */
|
403 |
|
|
|
404 |
|
|
static tree
|
405 |
|
|
maybe_cleanup_point_expr_void (tree expr)
|
406 |
|
|
{
|
407 |
|
|
if (!processing_template_decl && stmts_are_full_exprs_p ())
|
408 |
|
|
expr = fold_build_cleanup_point_expr (void_type_node, expr);
|
409 |
|
|
return expr;
|
410 |
|
|
}
|
411 |
|
|
|
412 |
|
|
|
413 |
|
|
|
414 |
|
|
/* Create a declaration statement for the declaration given by the DECL. */
|
415 |
|
|
|
416 |
|
|
void
|
417 |
|
|
add_decl_expr (tree decl)
|
418 |
|
|
{
|
419 |
|
|
tree r = build_stmt (DECL_EXPR, decl);
|
420 |
|
|
if (DECL_INITIAL (decl)
|
421 |
|
|
|| (DECL_SIZE (decl) && TREE_SIDE_EFFECTS (DECL_SIZE (decl))))
|
422 |
|
|
r = maybe_cleanup_point_expr_void (r);
|
423 |
|
|
add_stmt (r);
|
424 |
|
|
}
|
425 |
|
|
|
426 |
|
|
/* Nonzero if TYPE is an anonymous union or struct type. We have to use a
|
427 |
|
|
flag for this because "A union for which objects or pointers are
|
428 |
|
|
declared is not an anonymous union" [class.union]. */
|
429 |
|
|
|
430 |
|
|
int
|
431 |
|
|
anon_aggr_type_p (tree node)
|
432 |
|
|
{
|
433 |
|
|
return ANON_AGGR_TYPE_P (node);
|
434 |
|
|
}
|
435 |
|
|
|
436 |
|
|
/* Finish a scope. */
|
437 |
|
|
|
438 |
|
|
tree
|
439 |
|
|
do_poplevel (tree stmt_list)
|
440 |
|
|
{
|
441 |
|
|
tree block = NULL;
|
442 |
|
|
|
443 |
|
|
if (stmts_are_full_exprs_p ())
|
444 |
|
|
block = poplevel (kept_level_p (), 1, 0);
|
445 |
|
|
|
446 |
|
|
stmt_list = pop_stmt_list (stmt_list);
|
447 |
|
|
|
448 |
|
|
if (!processing_template_decl)
|
449 |
|
|
{
|
450 |
|
|
stmt_list = c_build_bind_expr (block, stmt_list);
|
451 |
|
|
/* ??? See c_end_compound_stmt re statement expressions. */
|
452 |
|
|
}
|
453 |
|
|
|
454 |
|
|
return stmt_list;
|
455 |
|
|
}
|
456 |
|
|
|
457 |
|
|
/* Begin a new scope. */
|
458 |
|
|
|
459 |
|
|
static tree
|
460 |
|
|
do_pushlevel (scope_kind sk)
|
461 |
|
|
{
|
462 |
|
|
tree ret = push_stmt_list ();
|
463 |
|
|
if (stmts_are_full_exprs_p ())
|
464 |
|
|
begin_scope (sk, NULL);
|
465 |
|
|
return ret;
|
466 |
|
|
}
|
467 |
|
|
|
468 |
|
|
/* Queue a cleanup. CLEANUP is an expression/statement to be executed
|
469 |
|
|
when the current scope is exited. EH_ONLY is true when this is not
|
470 |
|
|
meant to apply to normal control flow transfer. */
|
471 |
|
|
|
472 |
|
|
void
|
473 |
|
|
push_cleanup (tree decl, tree cleanup, bool eh_only)
|
474 |
|
|
{
|
475 |
|
|
tree stmt = build_stmt (CLEANUP_STMT, NULL, cleanup, decl);
|
476 |
|
|
CLEANUP_EH_ONLY (stmt) = eh_only;
|
477 |
|
|
add_stmt (stmt);
|
478 |
|
|
CLEANUP_BODY (stmt) = push_stmt_list ();
|
479 |
|
|
}
|
480 |
|
|
|
481 |
|
|
/* Begin a conditional that might contain a declaration. When generating
|
482 |
|
|
normal code, we want the declaration to appear before the statement
|
483 |
|
|
containing the conditional. When generating template code, we want the
|
484 |
|
|
conditional to be rendered as the raw DECL_EXPR. */
|
485 |
|
|
|
486 |
|
|
static void
|
487 |
|
|
begin_cond (tree *cond_p)
|
488 |
|
|
{
|
489 |
|
|
if (processing_template_decl)
|
490 |
|
|
*cond_p = push_stmt_list ();
|
491 |
|
|
}
|
492 |
|
|
|
493 |
|
|
/* Finish such a conditional. */
|
494 |
|
|
|
495 |
|
|
static void
|
496 |
|
|
finish_cond (tree *cond_p, tree expr)
|
497 |
|
|
{
|
498 |
|
|
if (processing_template_decl)
|
499 |
|
|
{
|
500 |
|
|
tree cond = pop_stmt_list (*cond_p);
|
501 |
|
|
if (TREE_CODE (cond) == DECL_EXPR)
|
502 |
|
|
expr = cond;
|
503 |
|
|
}
|
504 |
|
|
*cond_p = expr;
|
505 |
|
|
}
|
506 |
|
|
|
507 |
|
|
/* If *COND_P specifies a conditional with a declaration, transform the
|
508 |
|
|
loop such that
|
509 |
|
|
while (A x = 42) { }
|
510 |
|
|
for (; A x = 42;) { }
|
511 |
|
|
becomes
|
512 |
|
|
while (true) { A x = 42; if (!x) break; }
|
513 |
|
|
for (;;) { A x = 42; if (!x) break; }
|
514 |
|
|
The statement list for BODY will be empty if the conditional did
|
515 |
|
|
not declare anything. */
|
516 |
|
|
|
517 |
|
|
static void
|
518 |
|
|
simplify_loop_decl_cond (tree *cond_p, tree body)
|
519 |
|
|
{
|
520 |
|
|
tree cond, if_stmt;
|
521 |
|
|
|
522 |
|
|
if (!TREE_SIDE_EFFECTS (body))
|
523 |
|
|
return;
|
524 |
|
|
|
525 |
|
|
cond = *cond_p;
|
526 |
|
|
*cond_p = boolean_true_node;
|
527 |
|
|
|
528 |
|
|
if_stmt = begin_if_stmt ();
|
529 |
|
|
cond = build_unary_op (TRUTH_NOT_EXPR, cond, 0);
|
530 |
|
|
finish_if_stmt_cond (cond, if_stmt);
|
531 |
|
|
finish_break_stmt ();
|
532 |
|
|
finish_then_clause (if_stmt);
|
533 |
|
|
finish_if_stmt (if_stmt);
|
534 |
|
|
}
|
535 |
|
|
|
536 |
|
|
/* Finish a goto-statement. */
|
537 |
|
|
|
538 |
|
|
tree
|
539 |
|
|
finish_goto_stmt (tree destination)
|
540 |
|
|
{
|
541 |
|
|
if (TREE_CODE (destination) == IDENTIFIER_NODE)
|
542 |
|
|
destination = lookup_label (destination);
|
543 |
|
|
|
544 |
|
|
/* We warn about unused labels with -Wunused. That means we have to
|
545 |
|
|
mark the used labels as used. */
|
546 |
|
|
if (TREE_CODE (destination) == LABEL_DECL)
|
547 |
|
|
TREE_USED (destination) = 1;
|
548 |
|
|
else
|
549 |
|
|
{
|
550 |
|
|
/* The DESTINATION is being used as an rvalue. */
|
551 |
|
|
if (!processing_template_decl)
|
552 |
|
|
destination = decay_conversion (destination);
|
553 |
|
|
/* We don't inline calls to functions with computed gotos.
|
554 |
|
|
Those functions are typically up to some funny business,
|
555 |
|
|
and may be depending on the labels being at particular
|
556 |
|
|
addresses, or some such. */
|
557 |
|
|
DECL_UNINLINABLE (current_function_decl) = 1;
|
558 |
|
|
}
|
559 |
|
|
|
560 |
|
|
check_goto (destination);
|
561 |
|
|
|
562 |
|
|
return add_stmt (build_stmt (GOTO_EXPR, destination));
|
563 |
|
|
}
|
564 |
|
|
|
565 |
|
|
/* COND is the condition-expression for an if, while, etc.,
|
566 |
|
|
statement. Convert it to a boolean value, if appropriate. */
|
567 |
|
|
|
568 |
|
|
static tree
|
569 |
|
|
maybe_convert_cond (tree cond)
|
570 |
|
|
{
|
571 |
|
|
/* Empty conditions remain empty. */
|
572 |
|
|
if (!cond)
|
573 |
|
|
return NULL_TREE;
|
574 |
|
|
|
575 |
|
|
/* Wait until we instantiate templates before doing conversion. */
|
576 |
|
|
if (processing_template_decl)
|
577 |
|
|
return cond;
|
578 |
|
|
|
579 |
|
|
/* Do the conversion. */
|
580 |
|
|
cond = convert_from_reference (cond);
|
581 |
|
|
return condition_conversion (cond);
|
582 |
|
|
}
|
583 |
|
|
|
584 |
|
|
/* Finish an expression-statement, whose EXPRESSION is as indicated. */
|
585 |
|
|
|
586 |
|
|
tree
|
587 |
|
|
finish_expr_stmt (tree expr)
|
588 |
|
|
{
|
589 |
|
|
tree r = NULL_TREE;
|
590 |
|
|
|
591 |
|
|
if (expr != NULL_TREE)
|
592 |
|
|
{
|
593 |
|
|
if (!processing_template_decl)
|
594 |
|
|
{
|
595 |
|
|
if (warn_sequence_point)
|
596 |
|
|
verify_sequence_points (expr);
|
597 |
|
|
expr = convert_to_void (expr, "statement");
|
598 |
|
|
}
|
599 |
|
|
else if (!type_dependent_expression_p (expr))
|
600 |
|
|
convert_to_void (build_non_dependent_expr (expr), "statement");
|
601 |
|
|
|
602 |
|
|
/* Simplification of inner statement expressions, compound exprs,
|
603 |
|
|
etc can result in us already having an EXPR_STMT. */
|
604 |
|
|
if (TREE_CODE (expr) != CLEANUP_POINT_EXPR)
|
605 |
|
|
{
|
606 |
|
|
if (TREE_CODE (expr) != EXPR_STMT)
|
607 |
|
|
expr = build_stmt (EXPR_STMT, expr);
|
608 |
|
|
expr = maybe_cleanup_point_expr_void (expr);
|
609 |
|
|
}
|
610 |
|
|
|
611 |
|
|
r = add_stmt (expr);
|
612 |
|
|
}
|
613 |
|
|
|
614 |
|
|
finish_stmt ();
|
615 |
|
|
|
616 |
|
|
return r;
|
617 |
|
|
}
|
618 |
|
|
|
619 |
|
|
|
620 |
|
|
/* Begin an if-statement. Returns a newly created IF_STMT if
|
621 |
|
|
appropriate. */
|
622 |
|
|
|
623 |
|
|
tree
|
624 |
|
|
begin_if_stmt (void)
|
625 |
|
|
{
|
626 |
|
|
tree r, scope;
|
627 |
|
|
scope = do_pushlevel (sk_block);
|
628 |
|
|
r = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
|
629 |
|
|
TREE_CHAIN (r) = scope;
|
630 |
|
|
begin_cond (&IF_COND (r));
|
631 |
|
|
return r;
|
632 |
|
|
}
|
633 |
|
|
|
634 |
|
|
/* Process the COND of an if-statement, which may be given by
|
635 |
|
|
IF_STMT. */
|
636 |
|
|
|
637 |
|
|
void
|
638 |
|
|
finish_if_stmt_cond (tree cond, tree if_stmt)
|
639 |
|
|
{
|
640 |
|
|
finish_cond (&IF_COND (if_stmt), maybe_convert_cond (cond));
|
641 |
|
|
add_stmt (if_stmt);
|
642 |
|
|
THEN_CLAUSE (if_stmt) = push_stmt_list ();
|
643 |
|
|
}
|
644 |
|
|
|
645 |
|
|
/* Finish the then-clause of an if-statement, which may be given by
|
646 |
|
|
IF_STMT. */
|
647 |
|
|
|
648 |
|
|
tree
|
649 |
|
|
finish_then_clause (tree if_stmt)
|
650 |
|
|
{
|
651 |
|
|
THEN_CLAUSE (if_stmt) = pop_stmt_list (THEN_CLAUSE (if_stmt));
|
652 |
|
|
return if_stmt;
|
653 |
|
|
}
|
654 |
|
|
|
655 |
|
|
/* Begin the else-clause of an if-statement. */
|
656 |
|
|
|
657 |
|
|
void
|
658 |
|
|
begin_else_clause (tree if_stmt)
|
659 |
|
|
{
|
660 |
|
|
ELSE_CLAUSE (if_stmt) = push_stmt_list ();
|
661 |
|
|
}
|
662 |
|
|
|
663 |
|
|
/* Finish the else-clause of an if-statement, which may be given by
|
664 |
|
|
IF_STMT. */
|
665 |
|
|
|
666 |
|
|
void
|
667 |
|
|
finish_else_clause (tree if_stmt)
|
668 |
|
|
{
|
669 |
|
|
ELSE_CLAUSE (if_stmt) = pop_stmt_list (ELSE_CLAUSE (if_stmt));
|
670 |
|
|
}
|
671 |
|
|
|
672 |
|
|
/* Finish an if-statement. */
|
673 |
|
|
|
674 |
|
|
void
|
675 |
|
|
finish_if_stmt (tree if_stmt)
|
676 |
|
|
{
|
677 |
|
|
tree scope = TREE_CHAIN (if_stmt);
|
678 |
|
|
TREE_CHAIN (if_stmt) = NULL;
|
679 |
|
|
add_stmt (do_poplevel (scope));
|
680 |
|
|
finish_stmt ();
|
681 |
|
|
}
|
682 |
|
|
|
683 |
|
|
/* Begin a while-statement. Returns a newly created WHILE_STMT if
|
684 |
|
|
appropriate. */
|
685 |
|
|
|
686 |
|
|
tree
|
687 |
|
|
begin_while_stmt (void)
|
688 |
|
|
{
|
689 |
|
|
tree r;
|
690 |
|
|
r = build_stmt (WHILE_STMT, NULL_TREE, NULL_TREE);
|
691 |
|
|
add_stmt (r);
|
692 |
|
|
WHILE_BODY (r) = do_pushlevel (sk_block);
|
693 |
|
|
begin_cond (&WHILE_COND (r));
|
694 |
|
|
return r;
|
695 |
|
|
}
|
696 |
|
|
|
697 |
|
|
/* Process the COND of a while-statement, which may be given by
|
698 |
|
|
WHILE_STMT. */
|
699 |
|
|
|
700 |
|
|
void
|
701 |
|
|
finish_while_stmt_cond (tree cond, tree while_stmt)
|
702 |
|
|
{
|
703 |
|
|
finish_cond (&WHILE_COND (while_stmt), maybe_convert_cond (cond));
|
704 |
|
|
simplify_loop_decl_cond (&WHILE_COND (while_stmt), WHILE_BODY (while_stmt));
|
705 |
|
|
}
|
706 |
|
|
|
707 |
|
|
/* Finish a while-statement, which may be given by WHILE_STMT. */
|
708 |
|
|
|
709 |
|
|
void
|
710 |
|
|
finish_while_stmt (tree while_stmt)
|
711 |
|
|
{
|
712 |
|
|
WHILE_BODY (while_stmt) = do_poplevel (WHILE_BODY (while_stmt));
|
713 |
|
|
finish_stmt ();
|
714 |
|
|
}
|
715 |
|
|
|
716 |
|
|
/* Begin a do-statement. Returns a newly created DO_STMT if
|
717 |
|
|
appropriate. */
|
718 |
|
|
|
719 |
|
|
tree
|
720 |
|
|
begin_do_stmt (void)
|
721 |
|
|
{
|
722 |
|
|
tree r = build_stmt (DO_STMT, NULL_TREE, NULL_TREE);
|
723 |
|
|
add_stmt (r);
|
724 |
|
|
DO_BODY (r) = push_stmt_list ();
|
725 |
|
|
return r;
|
726 |
|
|
}
|
727 |
|
|
|
728 |
|
|
/* Finish the body of a do-statement, which may be given by DO_STMT. */
|
729 |
|
|
|
730 |
|
|
void
|
731 |
|
|
finish_do_body (tree do_stmt)
|
732 |
|
|
{
|
733 |
|
|
DO_BODY (do_stmt) = pop_stmt_list (DO_BODY (do_stmt));
|
734 |
|
|
}
|
735 |
|
|
|
736 |
|
|
/* Finish a do-statement, which may be given by DO_STMT, and whose
|
737 |
|
|
COND is as indicated. */
|
738 |
|
|
|
739 |
|
|
void
|
740 |
|
|
finish_do_stmt (tree cond, tree do_stmt)
|
741 |
|
|
{
|
742 |
|
|
cond = maybe_convert_cond (cond);
|
743 |
|
|
DO_COND (do_stmt) = cond;
|
744 |
|
|
finish_stmt ();
|
745 |
|
|
}
|
746 |
|
|
|
747 |
|
|
/* Finish a return-statement. The EXPRESSION returned, if any, is as
|
748 |
|
|
indicated. */
|
749 |
|
|
|
750 |
|
|
tree
|
751 |
|
|
finish_return_stmt (tree expr)
|
752 |
|
|
{
|
753 |
|
|
tree r;
|
754 |
|
|
bool no_warning;
|
755 |
|
|
|
756 |
|
|
expr = check_return_expr (expr, &no_warning);
|
757 |
|
|
if (!processing_template_decl)
|
758 |
|
|
{
|
759 |
|
|
if (DECL_DESTRUCTOR_P (current_function_decl)
|
760 |
|
|
|| (DECL_CONSTRUCTOR_P (current_function_decl)
|
761 |
|
|
&& targetm.cxx.cdtor_returns_this ()))
|
762 |
|
|
{
|
763 |
|
|
/* Similarly, all destructors must run destructors for
|
764 |
|
|
base-classes before returning. So, all returns in a
|
765 |
|
|
destructor get sent to the DTOR_LABEL; finish_function emits
|
766 |
|
|
code to return a value there. */
|
767 |
|
|
return finish_goto_stmt (cdtor_label);
|
768 |
|
|
}
|
769 |
|
|
}
|
770 |
|
|
|
771 |
|
|
r = build_stmt (RETURN_EXPR, expr);
|
772 |
|
|
TREE_NO_WARNING (r) |= no_warning;
|
773 |
|
|
r = maybe_cleanup_point_expr_void (r);
|
774 |
|
|
r = add_stmt (r);
|
775 |
|
|
finish_stmt ();
|
776 |
|
|
|
777 |
|
|
return r;
|
778 |
|
|
}
|
779 |
|
|
|
780 |
|
|
/* Begin a for-statement. Returns a new FOR_STMT if appropriate. */
|
781 |
|
|
|
782 |
|
|
tree
|
783 |
|
|
begin_for_stmt (void)
|
784 |
|
|
{
|
785 |
|
|
tree r;
|
786 |
|
|
|
787 |
|
|
r = build_stmt (FOR_STMT, NULL_TREE, NULL_TREE,
|
788 |
|
|
NULL_TREE, NULL_TREE);
|
789 |
|
|
|
790 |
|
|
if (flag_new_for_scope > 0)
|
791 |
|
|
TREE_CHAIN (r) = do_pushlevel (sk_for);
|
792 |
|
|
|
793 |
|
|
if (processing_template_decl)
|
794 |
|
|
FOR_INIT_STMT (r) = push_stmt_list ();
|
795 |
|
|
|
796 |
|
|
return r;
|
797 |
|
|
}
|
798 |
|
|
|
799 |
|
|
/* Finish the for-init-statement of a for-statement, which may be
|
800 |
|
|
given by FOR_STMT. */
|
801 |
|
|
|
802 |
|
|
void
|
803 |
|
|
finish_for_init_stmt (tree for_stmt)
|
804 |
|
|
{
|
805 |
|
|
if (processing_template_decl)
|
806 |
|
|
FOR_INIT_STMT (for_stmt) = pop_stmt_list (FOR_INIT_STMT (for_stmt));
|
807 |
|
|
add_stmt (for_stmt);
|
808 |
|
|
FOR_BODY (for_stmt) = do_pushlevel (sk_block);
|
809 |
|
|
begin_cond (&FOR_COND (for_stmt));
|
810 |
|
|
}
|
811 |
|
|
|
812 |
|
|
/* Finish the COND of a for-statement, which may be given by
|
813 |
|
|
FOR_STMT. */
|
814 |
|
|
|
815 |
|
|
void
|
816 |
|
|
finish_for_cond (tree cond, tree for_stmt)
|
817 |
|
|
{
|
818 |
|
|
finish_cond (&FOR_COND (for_stmt), maybe_convert_cond (cond));
|
819 |
|
|
simplify_loop_decl_cond (&FOR_COND (for_stmt), FOR_BODY (for_stmt));
|
820 |
|
|
}
|
821 |
|
|
|
822 |
|
|
/* Finish the increment-EXPRESSION in a for-statement, which may be
|
823 |
|
|
given by FOR_STMT. */
|
824 |
|
|
|
825 |
|
|
void
|
826 |
|
|
finish_for_expr (tree expr, tree for_stmt)
|
827 |
|
|
{
|
828 |
|
|
if (!expr)
|
829 |
|
|
return;
|
830 |
|
|
/* If EXPR is an overloaded function, issue an error; there is no
|
831 |
|
|
context available to use to perform overload resolution. */
|
832 |
|
|
if (type_unknown_p (expr))
|
833 |
|
|
{
|
834 |
|
|
cxx_incomplete_type_error (expr, TREE_TYPE (expr));
|
835 |
|
|
expr = error_mark_node;
|
836 |
|
|
}
|
837 |
|
|
if (!processing_template_decl)
|
838 |
|
|
{
|
839 |
|
|
if (warn_sequence_point)
|
840 |
|
|
verify_sequence_points (expr);
|
841 |
|
|
expr = convert_to_void (expr, "3rd expression in for");
|
842 |
|
|
}
|
843 |
|
|
else if (!type_dependent_expression_p (expr))
|
844 |
|
|
convert_to_void (build_non_dependent_expr (expr), "3rd expression in for");
|
845 |
|
|
expr = maybe_cleanup_point_expr_void (expr);
|
846 |
|
|
FOR_EXPR (for_stmt) = expr;
|
847 |
|
|
}
|
848 |
|
|
|
849 |
|
|
/* Finish the body of a for-statement, which may be given by
|
850 |
|
|
FOR_STMT. The increment-EXPR for the loop must be
|
851 |
|
|
provided. */
|
852 |
|
|
|
853 |
|
|
void
|
854 |
|
|
finish_for_stmt (tree for_stmt)
|
855 |
|
|
{
|
856 |
|
|
FOR_BODY (for_stmt) = do_poplevel (FOR_BODY (for_stmt));
|
857 |
|
|
|
858 |
|
|
/* Pop the scope for the body of the loop. */
|
859 |
|
|
if (flag_new_for_scope > 0)
|
860 |
|
|
{
|
861 |
|
|
tree scope = TREE_CHAIN (for_stmt);
|
862 |
|
|
TREE_CHAIN (for_stmt) = NULL;
|
863 |
|
|
add_stmt (do_poplevel (scope));
|
864 |
|
|
}
|
865 |
|
|
|
866 |
|
|
finish_stmt ();
|
867 |
|
|
}
|
868 |
|
|
|
869 |
|
|
/* Finish a break-statement. */
|
870 |
|
|
|
871 |
|
|
tree
|
872 |
|
|
finish_break_stmt (void)
|
873 |
|
|
{
|
874 |
|
|
return add_stmt (build_stmt (BREAK_STMT));
|
875 |
|
|
}
|
876 |
|
|
|
877 |
|
|
/* Finish a continue-statement. */
|
878 |
|
|
|
879 |
|
|
tree
|
880 |
|
|
finish_continue_stmt (void)
|
881 |
|
|
{
|
882 |
|
|
return add_stmt (build_stmt (CONTINUE_STMT));
|
883 |
|
|
}
|
884 |
|
|
|
885 |
|
|
/* Begin a switch-statement. Returns a new SWITCH_STMT if
|
886 |
|
|
appropriate. */
|
887 |
|
|
|
888 |
|
|
tree
|
889 |
|
|
begin_switch_stmt (void)
|
890 |
|
|
{
|
891 |
|
|
tree r, scope;
|
892 |
|
|
|
893 |
|
|
r = build_stmt (SWITCH_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
|
894 |
|
|
|
895 |
|
|
scope = do_pushlevel (sk_block);
|
896 |
|
|
TREE_CHAIN (r) = scope;
|
897 |
|
|
begin_cond (&SWITCH_STMT_COND (r));
|
898 |
|
|
|
899 |
|
|
return r;
|
900 |
|
|
}
|
901 |
|
|
|
902 |
|
|
/* Finish the cond of a switch-statement. */
|
903 |
|
|
|
904 |
|
|
void
|
905 |
|
|
finish_switch_cond (tree cond, tree switch_stmt)
|
906 |
|
|
{
|
907 |
|
|
tree orig_type = NULL;
|
908 |
|
|
if (!processing_template_decl)
|
909 |
|
|
{
|
910 |
|
|
tree index;
|
911 |
|
|
|
912 |
|
|
/* Convert the condition to an integer or enumeration type. */
|
913 |
|
|
cond = build_expr_type_conversion (WANT_INT | WANT_ENUM, cond, true);
|
914 |
|
|
if (cond == NULL_TREE)
|
915 |
|
|
{
|
916 |
|
|
error ("switch quantity not an integer");
|
917 |
|
|
cond = error_mark_node;
|
918 |
|
|
}
|
919 |
|
|
orig_type = TREE_TYPE (cond);
|
920 |
|
|
if (cond != error_mark_node)
|
921 |
|
|
{
|
922 |
|
|
/* [stmt.switch]
|
923 |
|
|
|
924 |
|
|
Integral promotions are performed. */
|
925 |
|
|
cond = perform_integral_promotions (cond);
|
926 |
|
|
cond = maybe_cleanup_point_expr (cond);
|
927 |
|
|
}
|
928 |
|
|
|
929 |
|
|
if (cond != error_mark_node)
|
930 |
|
|
{
|
931 |
|
|
index = get_unwidened (cond, NULL_TREE);
|
932 |
|
|
/* We can't strip a conversion from a signed type to an unsigned,
|
933 |
|
|
because if we did, int_fits_type_p would do the wrong thing
|
934 |
|
|
when checking case values for being in range,
|
935 |
|
|
and it's too hard to do the right thing. */
|
936 |
|
|
if (TYPE_UNSIGNED (TREE_TYPE (cond))
|
937 |
|
|
== TYPE_UNSIGNED (TREE_TYPE (index)))
|
938 |
|
|
cond = index;
|
939 |
|
|
}
|
940 |
|
|
}
|
941 |
|
|
finish_cond (&SWITCH_STMT_COND (switch_stmt), cond);
|
942 |
|
|
SWITCH_STMT_TYPE (switch_stmt) = orig_type;
|
943 |
|
|
add_stmt (switch_stmt);
|
944 |
|
|
push_switch (switch_stmt);
|
945 |
|
|
SWITCH_STMT_BODY (switch_stmt) = push_stmt_list ();
|
946 |
|
|
}
|
947 |
|
|
|
948 |
|
|
/* Finish the body of a switch-statement, which may be given by
|
949 |
|
|
SWITCH_STMT. The COND to switch on is indicated. */
|
950 |
|
|
|
951 |
|
|
void
|
952 |
|
|
finish_switch_stmt (tree switch_stmt)
|
953 |
|
|
{
|
954 |
|
|
tree scope;
|
955 |
|
|
|
956 |
|
|
SWITCH_STMT_BODY (switch_stmt) =
|
957 |
|
|
pop_stmt_list (SWITCH_STMT_BODY (switch_stmt));
|
958 |
|
|
pop_switch ();
|
959 |
|
|
finish_stmt ();
|
960 |
|
|
|
961 |
|
|
scope = TREE_CHAIN (switch_stmt);
|
962 |
|
|
TREE_CHAIN (switch_stmt) = NULL;
|
963 |
|
|
add_stmt (do_poplevel (scope));
|
964 |
|
|
}
|
965 |
|
|
|
966 |
|
|
/* Begin a try-block. Returns a newly-created TRY_BLOCK if
|
967 |
|
|
appropriate. */
|
968 |
|
|
|
969 |
|
|
tree
|
970 |
|
|
begin_try_block (void)
|
971 |
|
|
{
|
972 |
|
|
tree r = build_stmt (TRY_BLOCK, NULL_TREE, NULL_TREE);
|
973 |
|
|
add_stmt (r);
|
974 |
|
|
TRY_STMTS (r) = push_stmt_list ();
|
975 |
|
|
return r;
|
976 |
|
|
}
|
977 |
|
|
|
978 |
|
|
/* Likewise, for a function-try-block. */
|
979 |
|
|
|
980 |
|
|
tree
|
981 |
|
|
begin_function_try_block (void)
|
982 |
|
|
{
|
983 |
|
|
tree r = begin_try_block ();
|
984 |
|
|
FN_TRY_BLOCK_P (r) = 1;
|
985 |
|
|
return r;
|
986 |
|
|
}
|
987 |
|
|
|
988 |
|
|
/* Finish a try-block, which may be given by TRY_BLOCK. */
|
989 |
|
|
|
990 |
|
|
void
|
991 |
|
|
finish_try_block (tree try_block)
|
992 |
|
|
{
|
993 |
|
|
TRY_STMTS (try_block) = pop_stmt_list (TRY_STMTS (try_block));
|
994 |
|
|
TRY_HANDLERS (try_block) = push_stmt_list ();
|
995 |
|
|
}
|
996 |
|
|
|
997 |
|
|
/* Finish the body of a cleanup try-block, which may be given by
|
998 |
|
|
TRY_BLOCK. */
|
999 |
|
|
|
1000 |
|
|
void
|
1001 |
|
|
finish_cleanup_try_block (tree try_block)
|
1002 |
|
|
{
|
1003 |
|
|
TRY_STMTS (try_block) = pop_stmt_list (TRY_STMTS (try_block));
|
1004 |
|
|
}
|
1005 |
|
|
|
1006 |
|
|
/* Finish an implicitly generated try-block, with a cleanup is given
|
1007 |
|
|
by CLEANUP. */
|
1008 |
|
|
|
1009 |
|
|
void
|
1010 |
|
|
finish_cleanup (tree cleanup, tree try_block)
|
1011 |
|
|
{
|
1012 |
|
|
TRY_HANDLERS (try_block) = cleanup;
|
1013 |
|
|
CLEANUP_P (try_block) = 1;
|
1014 |
|
|
}
|
1015 |
|
|
|
1016 |
|
|
/* Likewise, for a function-try-block. */
|
1017 |
|
|
|
1018 |
|
|
void
|
1019 |
|
|
finish_function_try_block (tree try_block)
|
1020 |
|
|
{
|
1021 |
|
|
finish_try_block (try_block);
|
1022 |
|
|
/* FIXME : something queer about CTOR_INITIALIZER somehow following
|
1023 |
|
|
the try block, but moving it inside. */
|
1024 |
|
|
in_function_try_handler = 1;
|
1025 |
|
|
}
|
1026 |
|
|
|
1027 |
|
|
/* Finish a handler-sequence for a try-block, which may be given by
|
1028 |
|
|
TRY_BLOCK. */
|
1029 |
|
|
|
1030 |
|
|
void
|
1031 |
|
|
finish_handler_sequence (tree try_block)
|
1032 |
|
|
{
|
1033 |
|
|
TRY_HANDLERS (try_block) = pop_stmt_list (TRY_HANDLERS (try_block));
|
1034 |
|
|
check_handlers (TRY_HANDLERS (try_block));
|
1035 |
|
|
}
|
1036 |
|
|
|
1037 |
|
|
/* Likewise, for a function-try-block. */
|
1038 |
|
|
|
1039 |
|
|
void
|
1040 |
|
|
finish_function_handler_sequence (tree try_block)
|
1041 |
|
|
{
|
1042 |
|
|
in_function_try_handler = 0;
|
1043 |
|
|
finish_handler_sequence (try_block);
|
1044 |
|
|
}
|
1045 |
|
|
|
1046 |
|
|
/* Begin a handler. Returns a HANDLER if appropriate. */
|
1047 |
|
|
|
1048 |
|
|
tree
|
1049 |
|
|
begin_handler (void)
|
1050 |
|
|
{
|
1051 |
|
|
tree r;
|
1052 |
|
|
|
1053 |
|
|
r = build_stmt (HANDLER, NULL_TREE, NULL_TREE);
|
1054 |
|
|
add_stmt (r);
|
1055 |
|
|
|
1056 |
|
|
/* Create a binding level for the eh_info and the exception object
|
1057 |
|
|
cleanup. */
|
1058 |
|
|
HANDLER_BODY (r) = do_pushlevel (sk_catch);
|
1059 |
|
|
|
1060 |
|
|
return r;
|
1061 |
|
|
}
|
1062 |
|
|
|
1063 |
|
|
/* Finish the handler-parameters for a handler, which may be given by
|
1064 |
|
|
HANDLER. DECL is the declaration for the catch parameter, or NULL
|
1065 |
|
|
if this is a `catch (...)' clause. */
|
1066 |
|
|
|
1067 |
|
|
void
|
1068 |
|
|
finish_handler_parms (tree decl, tree handler)
|
1069 |
|
|
{
|
1070 |
|
|
tree type = NULL_TREE;
|
1071 |
|
|
if (processing_template_decl)
|
1072 |
|
|
{
|
1073 |
|
|
if (decl)
|
1074 |
|
|
{
|
1075 |
|
|
decl = pushdecl (decl);
|
1076 |
|
|
decl = push_template_decl (decl);
|
1077 |
|
|
HANDLER_PARMS (handler) = decl;
|
1078 |
|
|
type = TREE_TYPE (decl);
|
1079 |
|
|
}
|
1080 |
|
|
}
|
1081 |
|
|
else
|
1082 |
|
|
type = expand_start_catch_block (decl);
|
1083 |
|
|
|
1084 |
|
|
HANDLER_TYPE (handler) = type;
|
1085 |
|
|
if (!processing_template_decl && type)
|
1086 |
|
|
mark_used (eh_type_info (type));
|
1087 |
|
|
}
|
1088 |
|
|
|
1089 |
|
|
/* Finish a handler, which may be given by HANDLER. The BLOCKs are
|
1090 |
|
|
the return value from the matching call to finish_handler_parms. */
|
1091 |
|
|
|
1092 |
|
|
void
|
1093 |
|
|
finish_handler (tree handler)
|
1094 |
|
|
{
|
1095 |
|
|
if (!processing_template_decl)
|
1096 |
|
|
expand_end_catch_block ();
|
1097 |
|
|
HANDLER_BODY (handler) = do_poplevel (HANDLER_BODY (handler));
|
1098 |
|
|
}
|
1099 |
|
|
|
1100 |
|
|
/* Begin a compound statement. FLAGS contains some bits that control the
|
1101 |
|
|
behavior and context. If BCS_NO_SCOPE is set, the compound statement
|
1102 |
|
|
does not define a scope. If BCS_FN_BODY is set, this is the outermost
|
1103 |
|
|
block of a function. If BCS_TRY_BLOCK is set, this is the block
|
1104 |
|
|
created on behalf of a TRY statement. Returns a token to be passed to
|
1105 |
|
|
finish_compound_stmt. */
|
1106 |
|
|
|
1107 |
|
|
tree
|
1108 |
|
|
begin_compound_stmt (unsigned int flags)
|
1109 |
|
|
{
|
1110 |
|
|
tree r;
|
1111 |
|
|
|
1112 |
|
|
if (flags & BCS_NO_SCOPE)
|
1113 |
|
|
{
|
1114 |
|
|
r = push_stmt_list ();
|
1115 |
|
|
STATEMENT_LIST_NO_SCOPE (r) = 1;
|
1116 |
|
|
|
1117 |
|
|
/* Normally, we try hard to keep the BLOCK for a statement-expression.
|
1118 |
|
|
But, if it's a statement-expression with a scopeless block, there's
|
1119 |
|
|
nothing to keep, and we don't want to accidentally keep a block
|
1120 |
|
|
*inside* the scopeless block. */
|
1121 |
|
|
keep_next_level (false);
|
1122 |
|
|
}
|
1123 |
|
|
else
|
1124 |
|
|
r = do_pushlevel (flags & BCS_TRY_BLOCK ? sk_try : sk_block);
|
1125 |
|
|
|
1126 |
|
|
/* When processing a template, we need to remember where the braces were,
|
1127 |
|
|
so that we can set up identical scopes when instantiating the template
|
1128 |
|
|
later. BIND_EXPR is a handy candidate for this.
|
1129 |
|
|
Note that do_poplevel won't create a BIND_EXPR itself here (and thus
|
1130 |
|
|
result in nested BIND_EXPRs), since we don't build BLOCK nodes when
|
1131 |
|
|
processing templates. */
|
1132 |
|
|
if (processing_template_decl)
|
1133 |
|
|
{
|
1134 |
|
|
r = build3 (BIND_EXPR, NULL, NULL, r, NULL);
|
1135 |
|
|
BIND_EXPR_TRY_BLOCK (r) = (flags & BCS_TRY_BLOCK) != 0;
|
1136 |
|
|
BIND_EXPR_BODY_BLOCK (r) = (flags & BCS_FN_BODY) != 0;
|
1137 |
|
|
TREE_SIDE_EFFECTS (r) = 1;
|
1138 |
|
|
}
|
1139 |
|
|
|
1140 |
|
|
return r;
|
1141 |
|
|
}
|
1142 |
|
|
|
1143 |
|
|
/* Finish a compound-statement, which is given by STMT. */
|
1144 |
|
|
|
1145 |
|
|
void
|
1146 |
|
|
finish_compound_stmt (tree stmt)
|
1147 |
|
|
{
|
1148 |
|
|
if (TREE_CODE (stmt) == BIND_EXPR)
|
1149 |
|
|
BIND_EXPR_BODY (stmt) = do_poplevel (BIND_EXPR_BODY (stmt));
|
1150 |
|
|
else if (STATEMENT_LIST_NO_SCOPE (stmt))
|
1151 |
|
|
stmt = pop_stmt_list (stmt);
|
1152 |
|
|
else
|
1153 |
|
|
{
|
1154 |
|
|
/* Destroy any ObjC "super" receivers that may have been
|
1155 |
|
|
created. */
|
1156 |
|
|
objc_clear_super_receiver ();
|
1157 |
|
|
|
1158 |
|
|
stmt = do_poplevel (stmt);
|
1159 |
|
|
}
|
1160 |
|
|
|
1161 |
|
|
/* ??? See c_end_compound_stmt wrt statement expressions. */
|
1162 |
|
|
add_stmt (stmt);
|
1163 |
|
|
finish_stmt ();
|
1164 |
|
|
}
|
1165 |
|
|
|
1166 |
|
|
/* Finish an asm-statement, whose components are a STRING, some
|
1167 |
|
|
OUTPUT_OPERANDS, some INPUT_OPERANDS, and some CLOBBERS. Also note
|
1168 |
|
|
whether the asm-statement should be considered volatile. */
|
1169 |
|
|
|
1170 |
|
|
tree
|
1171 |
|
|
finish_asm_stmt (int volatile_p, tree string, tree output_operands,
|
1172 |
|
|
tree input_operands, tree clobbers)
|
1173 |
|
|
{
|
1174 |
|
|
tree r;
|
1175 |
|
|
tree t;
|
1176 |
|
|
int ninputs = list_length (input_operands);
|
1177 |
|
|
int noutputs = list_length (output_operands);
|
1178 |
|
|
|
1179 |
|
|
if (!processing_template_decl)
|
1180 |
|
|
{
|
1181 |
|
|
const char *constraint;
|
1182 |
|
|
const char **oconstraints;
|
1183 |
|
|
bool allows_mem, allows_reg, is_inout;
|
1184 |
|
|
tree operand;
|
1185 |
|
|
int i;
|
1186 |
|
|
|
1187 |
|
|
oconstraints = (const char **) alloca (noutputs * sizeof (char *));
|
1188 |
|
|
|
1189 |
|
|
string = resolve_asm_operand_names (string, output_operands,
|
1190 |
|
|
input_operands);
|
1191 |
|
|
|
1192 |
|
|
for (i = 0, t = output_operands; t; t = TREE_CHAIN (t), ++i)
|
1193 |
|
|
{
|
1194 |
|
|
operand = TREE_VALUE (t);
|
1195 |
|
|
|
1196 |
|
|
/* ??? Really, this should not be here. Users should be using a
|
1197 |
|
|
proper lvalue, dammit. But there's a long history of using
|
1198 |
|
|
casts in the output operands. In cases like longlong.h, this
|
1199 |
|
|
becomes a primitive form of typechecking -- if the cast can be
|
1200 |
|
|
removed, then the output operand had a type of the proper width;
|
1201 |
|
|
otherwise we'll get an error. Gross, but ... */
|
1202 |
|
|
STRIP_NOPS (operand);
|
1203 |
|
|
|
1204 |
|
|
if (!lvalue_or_else (operand, lv_asm))
|
1205 |
|
|
operand = error_mark_node;
|
1206 |
|
|
|
1207 |
|
|
if (operand != error_mark_node
|
1208 |
|
|
&& (TREE_READONLY (operand)
|
1209 |
|
|
|| CP_TYPE_CONST_P (TREE_TYPE (operand))
|
1210 |
|
|
/* Functions are not modifiable, even though they are
|
1211 |
|
|
lvalues. */
|
1212 |
|
|
|| TREE_CODE (TREE_TYPE (operand)) == FUNCTION_TYPE
|
1213 |
|
|
|| TREE_CODE (TREE_TYPE (operand)) == METHOD_TYPE
|
1214 |
|
|
/* If it's an aggregate and any field is const, then it is
|
1215 |
|
|
effectively const. */
|
1216 |
|
|
|| (CLASS_TYPE_P (TREE_TYPE (operand))
|
1217 |
|
|
&& C_TYPE_FIELDS_READONLY (TREE_TYPE (operand)))))
|
1218 |
|
|
readonly_error (operand, "assignment (via 'asm' output)", 0);
|
1219 |
|
|
|
1220 |
|
|
constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
|
1221 |
|
|
oconstraints[i] = constraint;
|
1222 |
|
|
|
1223 |
|
|
if (parse_output_constraint (&constraint, i, ninputs, noutputs,
|
1224 |
|
|
&allows_mem, &allows_reg, &is_inout))
|
1225 |
|
|
{
|
1226 |
|
|
/* If the operand is going to end up in memory,
|
1227 |
|
|
mark it addressable. */
|
1228 |
|
|
if (!allows_reg && !cxx_mark_addressable (operand))
|
1229 |
|
|
operand = error_mark_node;
|
1230 |
|
|
}
|
1231 |
|
|
else
|
1232 |
|
|
operand = error_mark_node;
|
1233 |
|
|
|
1234 |
|
|
TREE_VALUE (t) = operand;
|
1235 |
|
|
}
|
1236 |
|
|
|
1237 |
|
|
for (i = 0, t = input_operands; t; ++i, t = TREE_CHAIN (t))
|
1238 |
|
|
{
|
1239 |
|
|
constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (t)));
|
1240 |
|
|
operand = decay_conversion (TREE_VALUE (t));
|
1241 |
|
|
|
1242 |
|
|
/* If the type of the operand hasn't been determined (e.g.,
|
1243 |
|
|
because it involves an overloaded function), then issue
|
1244 |
|
|
an error message. There's no context available to
|
1245 |
|
|
resolve the overloading. */
|
1246 |
|
|
if (TREE_TYPE (operand) == unknown_type_node)
|
1247 |
|
|
{
|
1248 |
|
|
error ("type of asm operand %qE could not be determined",
|
1249 |
|
|
TREE_VALUE (t));
|
1250 |
|
|
operand = error_mark_node;
|
1251 |
|
|
}
|
1252 |
|
|
|
1253 |
|
|
if (parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
|
1254 |
|
|
oconstraints, &allows_mem, &allows_reg))
|
1255 |
|
|
{
|
1256 |
|
|
/* If the operand is going to end up in memory,
|
1257 |
|
|
mark it addressable. */
|
1258 |
|
|
if (!allows_reg && allows_mem)
|
1259 |
|
|
{
|
1260 |
|
|
/* Strip the nops as we allow this case. FIXME, this really
|
1261 |
|
|
should be rejected or made deprecated. */
|
1262 |
|
|
STRIP_NOPS (operand);
|
1263 |
|
|
if (!cxx_mark_addressable (operand))
|
1264 |
|
|
operand = error_mark_node;
|
1265 |
|
|
}
|
1266 |
|
|
}
|
1267 |
|
|
else
|
1268 |
|
|
operand = error_mark_node;
|
1269 |
|
|
|
1270 |
|
|
TREE_VALUE (t) = operand;
|
1271 |
|
|
}
|
1272 |
|
|
}
|
1273 |
|
|
|
1274 |
|
|
r = build_stmt (ASM_EXPR, string,
|
1275 |
|
|
output_operands, input_operands,
|
1276 |
|
|
clobbers);
|
1277 |
|
|
ASM_VOLATILE_P (r) = volatile_p || noutputs == 0;
|
1278 |
|
|
r = maybe_cleanup_point_expr_void (r);
|
1279 |
|
|
return add_stmt (r);
|
1280 |
|
|
}
|
1281 |
|
|
|
1282 |
|
|
/* Finish a label with the indicated NAME. */
|
1283 |
|
|
|
1284 |
|
|
tree
|
1285 |
|
|
finish_label_stmt (tree name)
|
1286 |
|
|
{
|
1287 |
|
|
tree decl = define_label (input_location, name);
|
1288 |
|
|
return add_stmt (build_stmt (LABEL_EXPR, decl));
|
1289 |
|
|
}
|
1290 |
|
|
|
1291 |
|
|
/* Finish a series of declarations for local labels. G++ allows users
|
1292 |
|
|
to declare "local" labels, i.e., labels with scope. This extension
|
1293 |
|
|
is useful when writing code involving statement-expressions. */
|
1294 |
|
|
|
1295 |
|
|
void
|
1296 |
|
|
finish_label_decl (tree name)
|
1297 |
|
|
{
|
1298 |
|
|
tree decl = declare_local_label (name);
|
1299 |
|
|
add_decl_expr (decl);
|
1300 |
|
|
}
|
1301 |
|
|
|
1302 |
|
|
/* When DECL goes out of scope, make sure that CLEANUP is executed. */
|
1303 |
|
|
|
1304 |
|
|
void
|
1305 |
|
|
finish_decl_cleanup (tree decl, tree cleanup)
|
1306 |
|
|
{
|
1307 |
|
|
push_cleanup (decl, cleanup, false);
|
1308 |
|
|
}
|
1309 |
|
|
|
1310 |
|
|
/* If the current scope exits with an exception, run CLEANUP. */
|
1311 |
|
|
|
1312 |
|
|
void
|
1313 |
|
|
finish_eh_cleanup (tree cleanup)
|
1314 |
|
|
{
|
1315 |
|
|
push_cleanup (NULL, cleanup, true);
|
1316 |
|
|
}
|
1317 |
|
|
|
1318 |
|
|
/* The MEM_INITS is a list of mem-initializers, in reverse of the
|
1319 |
|
|
order they were written by the user. Each node is as for
|
1320 |
|
|
emit_mem_initializers. */
|
1321 |
|
|
|
1322 |
|
|
void
|
1323 |
|
|
finish_mem_initializers (tree mem_inits)
|
1324 |
|
|
{
|
1325 |
|
|
/* Reorder the MEM_INITS so that they are in the order they appeared
|
1326 |
|
|
in the source program. */
|
1327 |
|
|
mem_inits = nreverse (mem_inits);
|
1328 |
|
|
|
1329 |
|
|
if (processing_template_decl)
|
1330 |
|
|
add_stmt (build_min_nt (CTOR_INITIALIZER, mem_inits));
|
1331 |
|
|
else
|
1332 |
|
|
emit_mem_initializers (mem_inits);
|
1333 |
|
|
}
|
1334 |
|
|
|
1335 |
|
|
/* Finish a parenthesized expression EXPR. */
|
1336 |
|
|
|
1337 |
|
|
tree
|
1338 |
|
|
finish_parenthesized_expr (tree expr)
|
1339 |
|
|
{
|
1340 |
|
|
if (EXPR_P (expr))
|
1341 |
|
|
/* This inhibits warnings in c_common_truthvalue_conversion. */
|
1342 |
|
|
TREE_NO_WARNING (expr) = 1;
|
1343 |
|
|
|
1344 |
|
|
if (TREE_CODE (expr) == OFFSET_REF)
|
1345 |
|
|
/* [expr.unary.op]/3 The qualified id of a pointer-to-member must not be
|
1346 |
|
|
enclosed in parentheses. */
|
1347 |
|
|
PTRMEM_OK_P (expr) = 0;
|
1348 |
|
|
|
1349 |
|
|
if (TREE_CODE (expr) == STRING_CST)
|
1350 |
|
|
PAREN_STRING_LITERAL_P (expr) = 1;
|
1351 |
|
|
|
1352 |
|
|
return expr;
|
1353 |
|
|
}
|
1354 |
|
|
|
1355 |
|
|
/* Finish a reference to a non-static data member (DECL) that is not
|
1356 |
|
|
preceded by `.' or `->'. */
|
1357 |
|
|
|
1358 |
|
|
tree
|
1359 |
|
|
finish_non_static_data_member (tree decl, tree object, tree qualifying_scope)
|
1360 |
|
|
{
|
1361 |
|
|
gcc_assert (TREE_CODE (decl) == FIELD_DECL);
|
1362 |
|
|
|
1363 |
|
|
if (!object)
|
1364 |
|
|
{
|
1365 |
|
|
if (current_function_decl
|
1366 |
|
|
&& DECL_STATIC_FUNCTION_P (current_function_decl))
|
1367 |
|
|
error ("invalid use of member %q+D in static member function", decl);
|
1368 |
|
|
else
|
1369 |
|
|
error ("invalid use of non-static data member %q+D", decl);
|
1370 |
|
|
error ("from this location");
|
1371 |
|
|
|
1372 |
|
|
return error_mark_node;
|
1373 |
|
|
}
|
1374 |
|
|
TREE_USED (current_class_ptr) = 1;
|
1375 |
|
|
if (processing_template_decl && !qualifying_scope)
|
1376 |
|
|
{
|
1377 |
|
|
tree type = TREE_TYPE (decl);
|
1378 |
|
|
|
1379 |
|
|
if (TREE_CODE (type) == REFERENCE_TYPE)
|
1380 |
|
|
type = TREE_TYPE (type);
|
1381 |
|
|
else
|
1382 |
|
|
{
|
1383 |
|
|
/* Set the cv qualifiers. */
|
1384 |
|
|
int quals = cp_type_quals (TREE_TYPE (current_class_ref));
|
1385 |
|
|
|
1386 |
|
|
if (DECL_MUTABLE_P (decl))
|
1387 |
|
|
quals &= ~TYPE_QUAL_CONST;
|
1388 |
|
|
|
1389 |
|
|
quals |= cp_type_quals (TREE_TYPE (decl));
|
1390 |
|
|
type = cp_build_qualified_type (type, quals);
|
1391 |
|
|
}
|
1392 |
|
|
|
1393 |
|
|
return build_min (COMPONENT_REF, type, object, decl, NULL_TREE);
|
1394 |
|
|
}
|
1395 |
|
|
else
|
1396 |
|
|
{
|
1397 |
|
|
tree access_type = TREE_TYPE (object);
|
1398 |
|
|
tree lookup_context = context_for_name_lookup (decl);
|
1399 |
|
|
|
1400 |
|
|
while (!DERIVED_FROM_P (lookup_context, access_type))
|
1401 |
|
|
{
|
1402 |
|
|
access_type = TYPE_CONTEXT (access_type);
|
1403 |
|
|
while (access_type && DECL_P (access_type))
|
1404 |
|
|
access_type = DECL_CONTEXT (access_type);
|
1405 |
|
|
|
1406 |
|
|
if (!access_type)
|
1407 |
|
|
{
|
1408 |
|
|
error ("object missing in reference to %q+D", decl);
|
1409 |
|
|
error ("from this location");
|
1410 |
|
|
return error_mark_node;
|
1411 |
|
|
}
|
1412 |
|
|
}
|
1413 |
|
|
|
1414 |
|
|
/* If PROCESSING_TEMPLATE_DECL is nonzero here, then
|
1415 |
|
|
QUALIFYING_SCOPE is also non-null. Wrap this in a SCOPE_REF
|
1416 |
|
|
for now. */
|
1417 |
|
|
if (processing_template_decl)
|
1418 |
|
|
return build_qualified_name (TREE_TYPE (decl),
|
1419 |
|
|
qualifying_scope,
|
1420 |
|
|
DECL_NAME (decl),
|
1421 |
|
|
/*template_p=*/false);
|
1422 |
|
|
|
1423 |
|
|
perform_or_defer_access_check (TYPE_BINFO (access_type), decl);
|
1424 |
|
|
|
1425 |
|
|
/* If the data member was named `C::M', convert `*this' to `C'
|
1426 |
|
|
first. */
|
1427 |
|
|
if (qualifying_scope)
|
1428 |
|
|
{
|
1429 |
|
|
tree binfo = NULL_TREE;
|
1430 |
|
|
object = build_scoped_ref (object, qualifying_scope,
|
1431 |
|
|
&binfo);
|
1432 |
|
|
}
|
1433 |
|
|
|
1434 |
|
|
return build_class_member_access_expr (object, decl,
|
1435 |
|
|
/*access_path=*/NULL_TREE,
|
1436 |
|
|
/*preserve_reference=*/false);
|
1437 |
|
|
}
|
1438 |
|
|
}
|
1439 |
|
|
|
1440 |
|
|
/* DECL was the declaration to which a qualified-id resolved. Issue
|
1441 |
|
|
an error message if it is not accessible. If OBJECT_TYPE is
|
1442 |
|
|
non-NULL, we have just seen `x->' or `x.' and OBJECT_TYPE is the
|
1443 |
|
|
type of `*x', or `x', respectively. If the DECL was named as
|
1444 |
|
|
`A::B' then NESTED_NAME_SPECIFIER is `A'. */
|
1445 |
|
|
|
1446 |
|
|
void
|
1447 |
|
|
check_accessibility_of_qualified_id (tree decl,
|
1448 |
|
|
tree object_type,
|
1449 |
|
|
tree nested_name_specifier)
|
1450 |
|
|
{
|
1451 |
|
|
tree scope;
|
1452 |
|
|
tree qualifying_type = NULL_TREE;
|
1453 |
|
|
|
1454 |
|
|
/* If we're not checking, return immediately. */
|
1455 |
|
|
if (deferred_access_no_check)
|
1456 |
|
|
return;
|
1457 |
|
|
|
1458 |
|
|
/* Determine the SCOPE of DECL. */
|
1459 |
|
|
scope = context_for_name_lookup (decl);
|
1460 |
|
|
/* If the SCOPE is not a type, then DECL is not a member. */
|
1461 |
|
|
if (!TYPE_P (scope))
|
1462 |
|
|
return;
|
1463 |
|
|
/* Compute the scope through which DECL is being accessed. */
|
1464 |
|
|
if (object_type
|
1465 |
|
|
/* OBJECT_TYPE might not be a class type; consider:
|
1466 |
|
|
|
1467 |
|
|
class A { typedef int I; };
|
1468 |
|
|
I *p;
|
1469 |
|
|
p->A::I::~I();
|
1470 |
|
|
|
1471 |
|
|
In this case, we will have "A::I" as the DECL, but "I" as the
|
1472 |
|
|
OBJECT_TYPE. */
|
1473 |
|
|
&& CLASS_TYPE_P (object_type)
|
1474 |
|
|
&& DERIVED_FROM_P (scope, object_type))
|
1475 |
|
|
/* If we are processing a `->' or `.' expression, use the type of the
|
1476 |
|
|
left-hand side. */
|
1477 |
|
|
qualifying_type = object_type;
|
1478 |
|
|
else if (nested_name_specifier)
|
1479 |
|
|
{
|
1480 |
|
|
/* If the reference is to a non-static member of the
|
1481 |
|
|
current class, treat it as if it were referenced through
|
1482 |
|
|
`this'. */
|
1483 |
|
|
if (DECL_NONSTATIC_MEMBER_P (decl)
|
1484 |
|
|
&& current_class_ptr
|
1485 |
|
|
&& DERIVED_FROM_P (scope, current_class_type))
|
1486 |
|
|
qualifying_type = current_class_type;
|
1487 |
|
|
/* Otherwise, use the type indicated by the
|
1488 |
|
|
nested-name-specifier. */
|
1489 |
|
|
else
|
1490 |
|
|
qualifying_type = nested_name_specifier;
|
1491 |
|
|
}
|
1492 |
|
|
else
|
1493 |
|
|
/* Otherwise, the name must be from the current class or one of
|
1494 |
|
|
its bases. */
|
1495 |
|
|
qualifying_type = currently_open_derived_class (scope);
|
1496 |
|
|
|
1497 |
|
|
if (qualifying_type && IS_AGGR_TYPE_CODE (TREE_CODE (qualifying_type)))
|
1498 |
|
|
/* It is possible for qualifying type to be a TEMPLATE_TYPE_PARM
|
1499 |
|
|
or similar in a default argument value. */
|
1500 |
|
|
perform_or_defer_access_check (TYPE_BINFO (qualifying_type), decl);
|
1501 |
|
|
}
|
1502 |
|
|
|
1503 |
|
|
/* EXPR is the result of a qualified-id. The QUALIFYING_CLASS was the
|
1504 |
|
|
class named to the left of the "::" operator. DONE is true if this
|
1505 |
|
|
expression is a complete postfix-expression; it is false if this
|
1506 |
|
|
expression is followed by '->', '[', '(', etc. ADDRESS_P is true
|
1507 |
|
|
iff this expression is the operand of '&'. TEMPLATE_P is true iff
|
1508 |
|
|
the qualified-id was of the form "A::template B". TEMPLATE_ARG_P
|
1509 |
|
|
is true iff this qualified name appears as a template argument. */
|
1510 |
|
|
|
1511 |
|
|
tree
|
1512 |
|
|
finish_qualified_id_expr (tree qualifying_class,
|
1513 |
|
|
tree expr,
|
1514 |
|
|
bool done,
|
1515 |
|
|
bool address_p,
|
1516 |
|
|
bool template_p,
|
1517 |
|
|
bool template_arg_p)
|
1518 |
|
|
{
|
1519 |
|
|
if (error_operand_p (expr))
|
1520 |
|
|
return error_mark_node;
|
1521 |
|
|
|
1522 |
|
|
if (template_p)
|
1523 |
|
|
check_template_keyword (expr);
|
1524 |
|
|
|
1525 |
|
|
if (DECL_P (expr))
|
1526 |
|
|
mark_used (expr);
|
1527 |
|
|
else if (BASELINK_P (expr)
|
1528 |
|
|
&& TREE_CODE (BASELINK_FUNCTIONS (expr)) != TEMPLATE_ID_EXPR
|
1529 |
|
|
&& !really_overloaded_fn (BASELINK_FUNCTIONS (expr)))
|
1530 |
|
|
mark_used (OVL_CURRENT (BASELINK_FUNCTIONS (expr)));
|
1531 |
|
|
|
1532 |
|
|
/* If EXPR occurs as the operand of '&', use special handling that
|
1533 |
|
|
permits a pointer-to-member. */
|
1534 |
|
|
if (address_p && done)
|
1535 |
|
|
{
|
1536 |
|
|
if (TREE_CODE (expr) == SCOPE_REF)
|
1537 |
|
|
expr = TREE_OPERAND (expr, 1);
|
1538 |
|
|
expr = build_offset_ref (qualifying_class, expr,
|
1539 |
|
|
/*address_p=*/true);
|
1540 |
|
|
return expr;
|
1541 |
|
|
}
|
1542 |
|
|
|
1543 |
|
|
/* Within the scope of a class, turn references to non-static
|
1544 |
|
|
members into expression of the form "this->...". */
|
1545 |
|
|
if (template_arg_p)
|
1546 |
|
|
/* But, within a template argument, we do not want make the
|
1547 |
|
|
transformation, as there is no "this" pointer. */
|
1548 |
|
|
;
|
1549 |
|
|
else if (TREE_CODE (expr) == FIELD_DECL)
|
1550 |
|
|
expr = finish_non_static_data_member (expr, current_class_ref,
|
1551 |
|
|
qualifying_class);
|
1552 |
|
|
else if (BASELINK_P (expr) && !processing_template_decl)
|
1553 |
|
|
{
|
1554 |
|
|
tree fns;
|
1555 |
|
|
|
1556 |
|
|
/* See if any of the functions are non-static members. */
|
1557 |
|
|
fns = BASELINK_FUNCTIONS (expr);
|
1558 |
|
|
if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
|
1559 |
|
|
fns = TREE_OPERAND (fns, 0);
|
1560 |
|
|
/* If so, the expression may be relative to the current
|
1561 |
|
|
class. */
|
1562 |
|
|
if (!shared_member_p (fns)
|
1563 |
|
|
&& current_class_type
|
1564 |
|
|
&& DERIVED_FROM_P (qualifying_class, current_class_type))
|
1565 |
|
|
expr = (build_class_member_access_expr
|
1566 |
|
|
(maybe_dummy_object (qualifying_class, NULL),
|
1567 |
|
|
expr,
|
1568 |
|
|
BASELINK_ACCESS_BINFO (expr),
|
1569 |
|
|
/*preserve_reference=*/false));
|
1570 |
|
|
else if (done)
|
1571 |
|
|
/* The expression is a qualified name whose address is not
|
1572 |
|
|
being taken. */
|
1573 |
|
|
expr = build_offset_ref (qualifying_class, expr, /*address_p=*/false);
|
1574 |
|
|
}
|
1575 |
|
|
|
1576 |
|
|
return expr;
|
1577 |
|
|
}
|
1578 |
|
|
|
1579 |
|
|
/* Begin a statement-expression. The value returned must be passed to
|
1580 |
|
|
finish_stmt_expr. */
|
1581 |
|
|
|
1582 |
|
|
tree
|
1583 |
|
|
begin_stmt_expr (void)
|
1584 |
|
|
{
|
1585 |
|
|
return push_stmt_list ();
|
1586 |
|
|
}
|
1587 |
|
|
|
1588 |
|
|
/* Process the final expression of a statement expression. EXPR can be
|
1589 |
|
|
NULL, if the final expression is empty. Return a STATEMENT_LIST
|
1590 |
|
|
containing all the statements in the statement-expression, or
|
1591 |
|
|
ERROR_MARK_NODE if there was an error. */
|
1592 |
|
|
|
1593 |
|
|
tree
|
1594 |
|
|
finish_stmt_expr_expr (tree expr, tree stmt_expr)
|
1595 |
|
|
{
|
1596 |
|
|
if (error_operand_p (expr))
|
1597 |
|
|
return error_mark_node;
|
1598 |
|
|
|
1599 |
|
|
/* If the last statement does not have "void" type, then the value
|
1600 |
|
|
of the last statement is the value of the entire expression. */
|
1601 |
|
|
if (expr)
|
1602 |
|
|
{
|
1603 |
|
|
tree type;
|
1604 |
|
|
type = TREE_TYPE (expr);
|
1605 |
|
|
if (!dependent_type_p (type) && !VOID_TYPE_P (type))
|
1606 |
|
|
{
|
1607 |
|
|
expr = decay_conversion (expr);
|
1608 |
|
|
if (error_operand_p (expr))
|
1609 |
|
|
return error_mark_node;
|
1610 |
|
|
type = TREE_TYPE (expr);
|
1611 |
|
|
}
|
1612 |
|
|
/* The type of the statement-expression is the type of the last
|
1613 |
|
|
expression. */
|
1614 |
|
|
TREE_TYPE (stmt_expr) = type;
|
1615 |
|
|
/* We must take particular care if TYPE is a class type. In
|
1616 |
|
|
particular if EXPR creates a temporary of class type, then it
|
1617 |
|
|
must be destroyed at the semicolon terminating the last
|
1618 |
|
|
statement -- but we must make a copy before that happens.
|
1619 |
|
|
|
1620 |
|
|
This problem is solved by using a TARGET_EXPR to initialize a
|
1621 |
|
|
new temporary variable. The TARGET_EXPR itself is placed
|
1622 |
|
|
outside the statement-expression. However, the last
|
1623 |
|
|
statement in the statement-expression is transformed from
|
1624 |
|
|
EXPR to (approximately) T = EXPR, where T is the new
|
1625 |
|
|
temporary variable. Thus, the lifetime of the new temporary
|
1626 |
|
|
extends to the full-expression surrounding the
|
1627 |
|
|
statement-expression. */
|
1628 |
|
|
if (!processing_template_decl && !VOID_TYPE_P (type))
|
1629 |
|
|
{
|
1630 |
|
|
tree target_expr;
|
1631 |
|
|
if (CLASS_TYPE_P (type)
|
1632 |
|
|
&& !TYPE_HAS_TRIVIAL_INIT_REF (type))
|
1633 |
|
|
{
|
1634 |
|
|
target_expr = build_target_expr_with_type (expr, type);
|
1635 |
|
|
expr = TARGET_EXPR_INITIAL (target_expr);
|
1636 |
|
|
}
|
1637 |
|
|
else
|
1638 |
|
|
{
|
1639 |
|
|
/* Normally, build_target_expr will not create a
|
1640 |
|
|
TARGET_EXPR for scalars. However, we need the
|
1641 |
|
|
temporary here, in order to solve the scoping
|
1642 |
|
|
problem described above. */
|
1643 |
|
|
target_expr = force_target_expr (type, expr);
|
1644 |
|
|
expr = TARGET_EXPR_INITIAL (target_expr);
|
1645 |
|
|
expr = build2 (INIT_EXPR,
|
1646 |
|
|
type,
|
1647 |
|
|
TARGET_EXPR_SLOT (target_expr),
|
1648 |
|
|
expr);
|
1649 |
|
|
}
|
1650 |
|
|
TARGET_EXPR_INITIAL (target_expr) = NULL_TREE;
|
1651 |
|
|
/* Save away the TARGET_EXPR in the TREE_TYPE field of the
|
1652 |
|
|
STATEMENT_EXPR. We will retrieve it in
|
1653 |
|
|
finish_stmt_expr. */
|
1654 |
|
|
TREE_TYPE (stmt_expr) = target_expr;
|
1655 |
|
|
}
|
1656 |
|
|
}
|
1657 |
|
|
|
1658 |
|
|
/* Having modified EXPR to reflect the extra initialization, we now
|
1659 |
|
|
treat it just like an ordinary statement. */
|
1660 |
|
|
expr = finish_expr_stmt (expr);
|
1661 |
|
|
|
1662 |
|
|
/* Mark the last statement so that we can recognize it as such at
|
1663 |
|
|
template-instantiation time. */
|
1664 |
|
|
if (expr && processing_template_decl)
|
1665 |
|
|
EXPR_STMT_STMT_EXPR_RESULT (expr) = 1;
|
1666 |
|
|
|
1667 |
|
|
return stmt_expr;
|
1668 |
|
|
}
|
1669 |
|
|
|
1670 |
|
|
/* Finish a statement-expression. EXPR should be the value returned
|
1671 |
|
|
by the previous begin_stmt_expr. Returns an expression
|
1672 |
|
|
representing the statement-expression. */
|
1673 |
|
|
|
1674 |
|
|
tree
|
1675 |
|
|
finish_stmt_expr (tree stmt_expr, bool has_no_scope)
|
1676 |
|
|
{
|
1677 |
|
|
tree type;
|
1678 |
|
|
tree result;
|
1679 |
|
|
|
1680 |
|
|
if (error_operand_p (stmt_expr))
|
1681 |
|
|
return error_mark_node;
|
1682 |
|
|
|
1683 |
|
|
gcc_assert (TREE_CODE (stmt_expr) == STATEMENT_LIST);
|
1684 |
|
|
|
1685 |
|
|
type = TREE_TYPE (stmt_expr);
|
1686 |
|
|
result = pop_stmt_list (stmt_expr);
|
1687 |
|
|
|
1688 |
|
|
if (processing_template_decl)
|
1689 |
|
|
{
|
1690 |
|
|
result = build_min (STMT_EXPR, type, result);
|
1691 |
|
|
TREE_SIDE_EFFECTS (result) = 1;
|
1692 |
|
|
STMT_EXPR_NO_SCOPE (result) = has_no_scope;
|
1693 |
|
|
}
|
1694 |
|
|
else if (!TYPE_P (type))
|
1695 |
|
|
{
|
1696 |
|
|
gcc_assert (TREE_CODE (type) == TARGET_EXPR);
|
1697 |
|
|
TARGET_EXPR_INITIAL (type) = result;
|
1698 |
|
|
TREE_TYPE (result) = void_type_node;
|
1699 |
|
|
result = type;
|
1700 |
|
|
}
|
1701 |
|
|
|
1702 |
|
|
return result;
|
1703 |
|
|
}
|
1704 |
|
|
|
1705 |
|
|
/* Perform Koenig lookup. FN is the postfix-expression representing
|
1706 |
|
|
the function (or functions) to call; ARGS are the arguments to the
|
1707 |
|
|
call. Returns the functions to be considered by overload
|
1708 |
|
|
resolution. */
|
1709 |
|
|
|
1710 |
|
|
tree
|
1711 |
|
|
perform_koenig_lookup (tree fn, tree args)
|
1712 |
|
|
{
|
1713 |
|
|
tree identifier = NULL_TREE;
|
1714 |
|
|
tree functions = NULL_TREE;
|
1715 |
|
|
|
1716 |
|
|
/* Find the name of the overloaded function. */
|
1717 |
|
|
if (TREE_CODE (fn) == IDENTIFIER_NODE)
|
1718 |
|
|
identifier = fn;
|
1719 |
|
|
else if (is_overloaded_fn (fn))
|
1720 |
|
|
{
|
1721 |
|
|
functions = fn;
|
1722 |
|
|
identifier = DECL_NAME (get_first_fn (functions));
|
1723 |
|
|
}
|
1724 |
|
|
else if (DECL_P (fn))
|
1725 |
|
|
{
|
1726 |
|
|
functions = fn;
|
1727 |
|
|
identifier = DECL_NAME (fn);
|
1728 |
|
|
}
|
1729 |
|
|
|
1730 |
|
|
/* A call to a namespace-scope function using an unqualified name.
|
1731 |
|
|
|
1732 |
|
|
Do Koenig lookup -- unless any of the arguments are
|
1733 |
|
|
type-dependent. */
|
1734 |
|
|
if (!any_type_dependent_arguments_p (args))
|
1735 |
|
|
{
|
1736 |
|
|
fn = lookup_arg_dependent (identifier, functions, args);
|
1737 |
|
|
if (!fn)
|
1738 |
|
|
/* The unqualified name could not be resolved. */
|
1739 |
|
|
fn = unqualified_fn_lookup_error (identifier);
|
1740 |
|
|
}
|
1741 |
|
|
|
1742 |
|
|
return fn;
|
1743 |
|
|
}
|
1744 |
|
|
|
1745 |
|
|
/* Generate an expression for `FN (ARGS)'.
|
1746 |
|
|
|
1747 |
|
|
If DISALLOW_VIRTUAL is true, the call to FN will be not generated
|
1748 |
|
|
as a virtual call, even if FN is virtual. (This flag is set when
|
1749 |
|
|
encountering an expression where the function name is explicitly
|
1750 |
|
|
qualified. For example a call to `X::f' never generates a virtual
|
1751 |
|
|
call.)
|
1752 |
|
|
|
1753 |
|
|
Returns code for the call. */
|
1754 |
|
|
|
1755 |
|
|
tree
|
1756 |
|
|
finish_call_expr (tree fn, tree args, bool disallow_virtual, bool koenig_p)
|
1757 |
|
|
{
|
1758 |
|
|
tree result;
|
1759 |
|
|
tree orig_fn;
|
1760 |
|
|
tree orig_args;
|
1761 |
|
|
|
1762 |
|
|
if (fn == error_mark_node || args == error_mark_node)
|
1763 |
|
|
return error_mark_node;
|
1764 |
|
|
|
1765 |
|
|
/* ARGS should be a list of arguments. */
|
1766 |
|
|
gcc_assert (!args || TREE_CODE (args) == TREE_LIST);
|
1767 |
|
|
|
1768 |
|
|
orig_fn = fn;
|
1769 |
|
|
orig_args = args;
|
1770 |
|
|
|
1771 |
|
|
if (processing_template_decl)
|
1772 |
|
|
{
|
1773 |
|
|
if (type_dependent_expression_p (fn)
|
1774 |
|
|
|| any_type_dependent_arguments_p (args))
|
1775 |
|
|
{
|
1776 |
|
|
result = build_nt (CALL_EXPR, fn, args, NULL_TREE);
|
1777 |
|
|
KOENIG_LOOKUP_P (result) = koenig_p;
|
1778 |
|
|
return result;
|
1779 |
|
|
}
|
1780 |
|
|
if (!BASELINK_P (fn)
|
1781 |
|
|
&& TREE_CODE (fn) != PSEUDO_DTOR_EXPR
|
1782 |
|
|
&& TREE_TYPE (fn) != unknown_type_node)
|
1783 |
|
|
fn = build_non_dependent_expr (fn);
|
1784 |
|
|
args = build_non_dependent_args (orig_args);
|
1785 |
|
|
}
|
1786 |
|
|
|
1787 |
|
|
/* A reference to a member function will appear as an overloaded
|
1788 |
|
|
function (rather than a BASELINK) if an unqualified name was used
|
1789 |
|
|
to refer to it. */
|
1790 |
|
|
if (!BASELINK_P (fn) && is_overloaded_fn (fn))
|
1791 |
|
|
{
|
1792 |
|
|
tree f = fn;
|
1793 |
|
|
|
1794 |
|
|
if (TREE_CODE (f) == TEMPLATE_ID_EXPR)
|
1795 |
|
|
f = TREE_OPERAND (f, 0);
|
1796 |
|
|
f = get_first_fn (f);
|
1797 |
|
|
if (DECL_FUNCTION_MEMBER_P (f))
|
1798 |
|
|
{
|
1799 |
|
|
tree type = currently_open_derived_class (DECL_CONTEXT (f));
|
1800 |
|
|
if (!type)
|
1801 |
|
|
type = DECL_CONTEXT (f);
|
1802 |
|
|
fn = build_baselink (TYPE_BINFO (type),
|
1803 |
|
|
TYPE_BINFO (type),
|
1804 |
|
|
fn, /*optype=*/NULL_TREE);
|
1805 |
|
|
}
|
1806 |
|
|
}
|
1807 |
|
|
|
1808 |
|
|
result = NULL_TREE;
|
1809 |
|
|
if (BASELINK_P (fn))
|
1810 |
|
|
{
|
1811 |
|
|
tree object;
|
1812 |
|
|
|
1813 |
|
|
/* A call to a member function. From [over.call.func]:
|
1814 |
|
|
|
1815 |
|
|
If the keyword this is in scope and refers to the class of
|
1816 |
|
|
that member function, or a derived class thereof, then the
|
1817 |
|
|
function call is transformed into a qualified function call
|
1818 |
|
|
using (*this) as the postfix-expression to the left of the
|
1819 |
|
|
. operator.... [Otherwise] a contrived object of type T
|
1820 |
|
|
becomes the implied object argument.
|
1821 |
|
|
|
1822 |
|
|
This paragraph is unclear about this situation:
|
1823 |
|
|
|
1824 |
|
|
struct A { void f(); };
|
1825 |
|
|
struct B : public A {};
|
1826 |
|
|
struct C : public A { void g() { B::f(); }};
|
1827 |
|
|
|
1828 |
|
|
In particular, for `B::f', this paragraph does not make clear
|
1829 |
|
|
whether "the class of that member function" refers to `A' or
|
1830 |
|
|
to `B'. We believe it refers to `B'. */
|
1831 |
|
|
if (current_class_type
|
1832 |
|
|
&& DERIVED_FROM_P (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn)),
|
1833 |
|
|
current_class_type)
|
1834 |
|
|
&& current_class_ref)
|
1835 |
|
|
object = maybe_dummy_object (BINFO_TYPE (BASELINK_ACCESS_BINFO (fn)),
|
1836 |
|
|
NULL);
|
1837 |
|
|
else
|
1838 |
|
|
{
|
1839 |
|
|
tree representative_fn;
|
1840 |
|
|
|
1841 |
|
|
representative_fn = BASELINK_FUNCTIONS (fn);
|
1842 |
|
|
if (TREE_CODE (representative_fn) == TEMPLATE_ID_EXPR)
|
1843 |
|
|
representative_fn = TREE_OPERAND (representative_fn, 0);
|
1844 |
|
|
representative_fn = get_first_fn (representative_fn);
|
1845 |
|
|
object = build_dummy_object (DECL_CONTEXT (representative_fn));
|
1846 |
|
|
}
|
1847 |
|
|
|
1848 |
|
|
if (processing_template_decl)
|
1849 |
|
|
{
|
1850 |
|
|
if (type_dependent_expression_p (object))
|
1851 |
|
|
return build_nt (CALL_EXPR, orig_fn, orig_args, NULL_TREE);
|
1852 |
|
|
object = build_non_dependent_expr (object);
|
1853 |
|
|
}
|
1854 |
|
|
|
1855 |
|
|
result = build_new_method_call (object, fn, args, NULL_TREE,
|
1856 |
|
|
(disallow_virtual
|
1857 |
|
|
? LOOKUP_NONVIRTUAL : 0));
|
1858 |
|
|
}
|
1859 |
|
|
else if (is_overloaded_fn (fn))
|
1860 |
|
|
{
|
1861 |
|
|
/* If the function is an overloaded builtin, resolve it. */
|
1862 |
|
|
if (TREE_CODE (fn) == FUNCTION_DECL
|
1863 |
|
|
&& (DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL
|
1864 |
|
|
|| DECL_BUILT_IN_CLASS (fn) == BUILT_IN_MD))
|
1865 |
|
|
result = resolve_overloaded_builtin (fn, args);
|
1866 |
|
|
|
1867 |
|
|
if (!result)
|
1868 |
|
|
/* A call to a namespace-scope function. */
|
1869 |
|
|
result = build_new_function_call (fn, args, koenig_p);
|
1870 |
|
|
}
|
1871 |
|
|
else if (TREE_CODE (fn) == PSEUDO_DTOR_EXPR)
|
1872 |
|
|
{
|
1873 |
|
|
if (args)
|
1874 |
|
|
error ("arguments to destructor are not allowed");
|
1875 |
|
|
/* Mark the pseudo-destructor call as having side-effects so
|
1876 |
|
|
that we do not issue warnings about its use. */
|
1877 |
|
|
result = build1 (NOP_EXPR,
|
1878 |
|
|
void_type_node,
|
1879 |
|
|
TREE_OPERAND (fn, 0));
|
1880 |
|
|
TREE_SIDE_EFFECTS (result) = 1;
|
1881 |
|
|
}
|
1882 |
|
|
else if (CLASS_TYPE_P (TREE_TYPE (fn)))
|
1883 |
|
|
/* If the "function" is really an object of class type, it might
|
1884 |
|
|
have an overloaded `operator ()'. */
|
1885 |
|
|
result = build_new_op (CALL_EXPR, LOOKUP_NORMAL, fn, args, NULL_TREE,
|
1886 |
|
|
/*overloaded_p=*/NULL);
|
1887 |
|
|
|
1888 |
|
|
if (!result)
|
1889 |
|
|
/* A call where the function is unknown. */
|
1890 |
|
|
result = build_function_call (fn, args);
|
1891 |
|
|
|
1892 |
|
|
if (processing_template_decl)
|
1893 |
|
|
{
|
1894 |
|
|
result = build3 (CALL_EXPR, TREE_TYPE (result), orig_fn,
|
1895 |
|
|
orig_args, NULL_TREE);
|
1896 |
|
|
KOENIG_LOOKUP_P (result) = koenig_p;
|
1897 |
|
|
}
|
1898 |
|
|
return result;
|
1899 |
|
|
}
|
1900 |
|
|
|
1901 |
|
|
/* Finish a call to a postfix increment or decrement or EXPR. (Which
|
1902 |
|
|
is indicated by CODE, which should be POSTINCREMENT_EXPR or
|
1903 |
|
|
POSTDECREMENT_EXPR.) */
|
1904 |
|
|
|
1905 |
|
|
tree
|
1906 |
|
|
finish_increment_expr (tree expr, enum tree_code code)
|
1907 |
|
|
{
|
1908 |
|
|
return build_x_unary_op (code, expr);
|
1909 |
|
|
}
|
1910 |
|
|
|
1911 |
|
|
/* Finish a use of `this'. Returns an expression for `this'. */
|
1912 |
|
|
|
1913 |
|
|
tree
|
1914 |
|
|
finish_this_expr (void)
|
1915 |
|
|
{
|
1916 |
|
|
tree result;
|
1917 |
|
|
|
1918 |
|
|
if (current_class_ptr)
|
1919 |
|
|
{
|
1920 |
|
|
result = current_class_ptr;
|
1921 |
|
|
}
|
1922 |
|
|
else if (current_function_decl
|
1923 |
|
|
&& DECL_STATIC_FUNCTION_P (current_function_decl))
|
1924 |
|
|
{
|
1925 |
|
|
error ("%<this%> is unavailable for static member functions");
|
1926 |
|
|
result = error_mark_node;
|
1927 |
|
|
}
|
1928 |
|
|
else
|
1929 |
|
|
{
|
1930 |
|
|
if (current_function_decl)
|
1931 |
|
|
error ("invalid use of %<this%> in non-member function");
|
1932 |
|
|
else
|
1933 |
|
|
error ("invalid use of %<this%> at top level");
|
1934 |
|
|
result = error_mark_node;
|
1935 |
|
|
}
|
1936 |
|
|
|
1937 |
|
|
return result;
|
1938 |
|
|
}
|
1939 |
|
|
|
1940 |
|
|
/* Finish a pseudo-destructor expression. If SCOPE is NULL, the
|
1941 |
|
|
expression was of the form `OBJECT.~DESTRUCTOR' where DESTRUCTOR is
|
1942 |
|
|
the TYPE for the type given. If SCOPE is non-NULL, the expression
|
1943 |
|
|
was of the form `OBJECT.SCOPE::~DESTRUCTOR'. */
|
1944 |
|
|
|
1945 |
|
|
tree
|
1946 |
|
|
finish_pseudo_destructor_expr (tree object, tree scope, tree destructor)
|
1947 |
|
|
{
|
1948 |
|
|
if (destructor == error_mark_node)
|
1949 |
|
|
return error_mark_node;
|
1950 |
|
|
|
1951 |
|
|
gcc_assert (TYPE_P (destructor));
|
1952 |
|
|
|
1953 |
|
|
if (!processing_template_decl)
|
1954 |
|
|
{
|
1955 |
|
|
if (scope == error_mark_node)
|
1956 |
|
|
{
|
1957 |
|
|
error ("invalid qualifying scope in pseudo-destructor name");
|
1958 |
|
|
return error_mark_node;
|
1959 |
|
|
}
|
1960 |
|
|
|
1961 |
|
|
/* [expr.pseudo] says both:
|
1962 |
|
|
|
1963 |
|
|
The type designated by the pseudo-destructor-name shall be
|
1964 |
|
|
the same as the object type.
|
1965 |
|
|
|
1966 |
|
|
and:
|
1967 |
|
|
|
1968 |
|
|
The cv-unqualified versions of the object type and of the
|
1969 |
|
|
type designated by the pseudo-destructor-name shall be the
|
1970 |
|
|
same type.
|
1971 |
|
|
|
1972 |
|
|
We implement the more generous second sentence, since that is
|
1973 |
|
|
what most other compilers do. */
|
1974 |
|
|
if (!same_type_ignoring_top_level_qualifiers_p (TREE_TYPE (object),
|
1975 |
|
|
destructor))
|
1976 |
|
|
{
|
1977 |
|
|
error ("%qE is not of type %qT", object, destructor);
|
1978 |
|
|
return error_mark_node;
|
1979 |
|
|
}
|
1980 |
|
|
}
|
1981 |
|
|
|
1982 |
|
|
return build3 (PSEUDO_DTOR_EXPR, void_type_node, object, scope, destructor);
|
1983 |
|
|
}
|
1984 |
|
|
|
1985 |
|
|
/* Finish an expression of the form CODE EXPR. */
|
1986 |
|
|
|
1987 |
|
|
tree
|
1988 |
|
|
finish_unary_op_expr (enum tree_code code, tree expr)
|
1989 |
|
|
{
|
1990 |
|
|
tree result = build_x_unary_op (code, expr);
|
1991 |
|
|
/* Inside a template, build_x_unary_op does not fold the
|
1992 |
|
|
expression. So check whether the result is folded before
|
1993 |
|
|
setting TREE_NEGATED_INT. */
|
1994 |
|
|
if (code == NEGATE_EXPR && TREE_CODE (expr) == INTEGER_CST
|
1995 |
|
|
&& TREE_CODE (result) == INTEGER_CST
|
1996 |
|
|
&& !TYPE_UNSIGNED (TREE_TYPE (result))
|
1997 |
|
|
&& INT_CST_LT (result, integer_zero_node))
|
1998 |
|
|
{
|
1999 |
|
|
/* RESULT may be a cached INTEGER_CST, so we must copy it before
|
2000 |
|
|
setting TREE_NEGATED_INT. */
|
2001 |
|
|
result = copy_node (result);
|
2002 |
|
|
TREE_NEGATED_INT (result) = 1;
|
2003 |
|
|
}
|
2004 |
|
|
overflow_warning (result);
|
2005 |
|
|
return result;
|
2006 |
|
|
}
|
2007 |
|
|
|
2008 |
|
|
/* Finish a compound-literal expression. TYPE is the type to which
|
2009 |
|
|
the INITIALIZER_LIST is being cast. */
|
2010 |
|
|
|
2011 |
|
|
tree
|
2012 |
|
|
finish_compound_literal (tree type, VEC(constructor_elt,gc) *initializer_list)
|
2013 |
|
|
{
|
2014 |
|
|
tree compound_literal;
|
2015 |
|
|
|
2016 |
|
|
/* Build a CONSTRUCTOR for the INITIALIZER_LIST. */
|
2017 |
|
|
compound_literal = build_constructor (NULL_TREE, initializer_list);
|
2018 |
|
|
if (processing_template_decl)
|
2019 |
|
|
TREE_TYPE (compound_literal) = type;
|
2020 |
|
|
else
|
2021 |
|
|
{
|
2022 |
|
|
/* Check the initialization. */
|
2023 |
|
|
compound_literal = reshape_init (type, compound_literal);
|
2024 |
|
|
compound_literal = digest_init (type, compound_literal);
|
2025 |
|
|
/* If the TYPE was an array type with an unknown bound, then we can
|
2026 |
|
|
figure out the dimension now. For example, something like:
|
2027 |
|
|
|
2028 |
|
|
`(int []) { 2, 3 }'
|
2029 |
|
|
|
2030 |
|
|
implies that the array has two elements. */
|
2031 |
|
|
if (TREE_CODE (type) == ARRAY_TYPE && !COMPLETE_TYPE_P (type))
|
2032 |
|
|
cp_complete_array_type (&TREE_TYPE (compound_literal),
|
2033 |
|
|
compound_literal, 1);
|
2034 |
|
|
}
|
2035 |
|
|
|
2036 |
|
|
/* Mark it as a compound-literal. */
|
2037 |
|
|
if (TREE_CODE (compound_literal) == CONSTRUCTOR)
|
2038 |
|
|
TREE_HAS_CONSTRUCTOR (compound_literal) = 1;
|
2039 |
|
|
|
2040 |
|
|
return compound_literal;
|
2041 |
|
|
}
|
2042 |
|
|
|
2043 |
|
|
/* Return the declaration for the function-name variable indicated by
|
2044 |
|
|
ID. */
|
2045 |
|
|
|
2046 |
|
|
tree
|
2047 |
|
|
finish_fname (tree id)
|
2048 |
|
|
{
|
2049 |
|
|
tree decl;
|
2050 |
|
|
|
2051 |
|
|
decl = fname_decl (C_RID_CODE (id), id);
|
2052 |
|
|
if (processing_template_decl)
|
2053 |
|
|
decl = DECL_NAME (decl);
|
2054 |
|
|
return decl;
|
2055 |
|
|
}
|
2056 |
|
|
|
2057 |
|
|
/* Finish a translation unit. */
|
2058 |
|
|
|
2059 |
|
|
void
|
2060 |
|
|
finish_translation_unit (void)
|
2061 |
|
|
{
|
2062 |
|
|
/* In case there were missing closebraces,
|
2063 |
|
|
get us back to the global binding level. */
|
2064 |
|
|
pop_everything ();
|
2065 |
|
|
while (current_namespace != global_namespace)
|
2066 |
|
|
pop_namespace ();
|
2067 |
|
|
|
2068 |
|
|
/* Do file scope __FUNCTION__ et al. */
|
2069 |
|
|
finish_fname_decls ();
|
2070 |
|
|
}
|
2071 |
|
|
|
2072 |
|
|
/* Finish a template type parameter, specified as AGGR IDENTIFIER.
|
2073 |
|
|
Returns the parameter. */
|
2074 |
|
|
|
2075 |
|
|
tree
|
2076 |
|
|
finish_template_type_parm (tree aggr, tree identifier)
|
2077 |
|
|
{
|
2078 |
|
|
if (aggr != class_type_node)
|
2079 |
|
|
{
|
2080 |
|
|
pedwarn ("template type parameters must use the keyword %<class%> or %<typename%>");
|
2081 |
|
|
aggr = class_type_node;
|
2082 |
|
|
}
|
2083 |
|
|
|
2084 |
|
|
return build_tree_list (aggr, identifier);
|
2085 |
|
|
}
|
2086 |
|
|
|
2087 |
|
|
/* Finish a template template parameter, specified as AGGR IDENTIFIER.
|
2088 |
|
|
Returns the parameter. */
|
2089 |
|
|
|
2090 |
|
|
tree
|
2091 |
|
|
finish_template_template_parm (tree aggr, tree identifier)
|
2092 |
|
|
{
|
2093 |
|
|
tree decl = build_decl (TYPE_DECL, identifier, NULL_TREE);
|
2094 |
|
|
tree tmpl = build_lang_decl (TEMPLATE_DECL, identifier, NULL_TREE);
|
2095 |
|
|
DECL_TEMPLATE_PARMS (tmpl) = current_template_parms;
|
2096 |
|
|
DECL_TEMPLATE_RESULT (tmpl) = decl;
|
2097 |
|
|
DECL_ARTIFICIAL (decl) = 1;
|
2098 |
|
|
end_template_decl ();
|
2099 |
|
|
|
2100 |
|
|
gcc_assert (DECL_TEMPLATE_PARMS (tmpl));
|
2101 |
|
|
|
2102 |
|
|
return finish_template_type_parm (aggr, tmpl);
|
2103 |
|
|
}
|
2104 |
|
|
|
2105 |
|
|
/* ARGUMENT is the default-argument value for a template template
|
2106 |
|
|
parameter. If ARGUMENT is invalid, issue error messages and return
|
2107 |
|
|
the ERROR_MARK_NODE. Otherwise, ARGUMENT itself is returned. */
|
2108 |
|
|
|
2109 |
|
|
tree
|
2110 |
|
|
check_template_template_default_arg (tree argument)
|
2111 |
|
|
{
|
2112 |
|
|
if (TREE_CODE (argument) != TEMPLATE_DECL
|
2113 |
|
|
&& TREE_CODE (argument) != TEMPLATE_TEMPLATE_PARM
|
2114 |
|
|
&& TREE_CODE (argument) != UNBOUND_CLASS_TEMPLATE)
|
2115 |
|
|
{
|
2116 |
|
|
if (TREE_CODE (argument) == TYPE_DECL)
|
2117 |
|
|
{
|
2118 |
|
|
tree t = TREE_TYPE (argument);
|
2119 |
|
|
|
2120 |
|
|
/* Try to emit a slightly smarter error message if we detect
|
2121 |
|
|
that the user is using a template instantiation. */
|
2122 |
|
|
if (CLASSTYPE_TEMPLATE_INFO (t)
|
2123 |
|
|
&& CLASSTYPE_TEMPLATE_INSTANTIATION (t))
|
2124 |
|
|
error ("invalid use of type %qT as a default value for a "
|
2125 |
|
|
"template template-parameter", t);
|
2126 |
|
|
else
|
2127 |
|
|
error ("invalid use of %qD as a default value for a template "
|
2128 |
|
|
"template-parameter", argument);
|
2129 |
|
|
}
|
2130 |
|
|
else
|
2131 |
|
|
error ("invalid default argument for a template template parameter");
|
2132 |
|
|
return error_mark_node;
|
2133 |
|
|
}
|
2134 |
|
|
|
2135 |
|
|
return argument;
|
2136 |
|
|
}
|
2137 |
|
|
|
2138 |
|
|
/* Begin a class definition, as indicated by T. */
|
2139 |
|
|
|
2140 |
|
|
tree
|
2141 |
|
|
begin_class_definition (tree t)
|
2142 |
|
|
{
|
2143 |
|
|
if (t == error_mark_node)
|
2144 |
|
|
return error_mark_node;
|
2145 |
|
|
|
2146 |
|
|
if (processing_template_parmlist)
|
2147 |
|
|
{
|
2148 |
|
|
error ("definition of %q#T inside template parameter list", t);
|
2149 |
|
|
return error_mark_node;
|
2150 |
|
|
}
|
2151 |
|
|
/* A non-implicit typename comes from code like:
|
2152 |
|
|
|
2153 |
|
|
template <typename T> struct A {
|
2154 |
|
|
template <typename U> struct A<T>::B ...
|
2155 |
|
|
|
2156 |
|
|
This is erroneous. */
|
2157 |
|
|
else if (TREE_CODE (t) == TYPENAME_TYPE)
|
2158 |
|
|
{
|
2159 |
|
|
error ("invalid definition of qualified type %qT", t);
|
2160 |
|
|
t = error_mark_node;
|
2161 |
|
|
}
|
2162 |
|
|
|
2163 |
|
|
if (t == error_mark_node || ! IS_AGGR_TYPE (t))
|
2164 |
|
|
{
|
2165 |
|
|
t = make_aggr_type (RECORD_TYPE);
|
2166 |
|
|
pushtag (make_anon_name (), t, /*tag_scope=*/ts_current);
|
2167 |
|
|
}
|
2168 |
|
|
|
2169 |
|
|
/* Update the location of the decl. */
|
2170 |
|
|
DECL_SOURCE_LOCATION (TYPE_NAME (t)) = input_location;
|
2171 |
|
|
|
2172 |
|
|
if (TYPE_BEING_DEFINED (t))
|
2173 |
|
|
{
|
2174 |
|
|
t = make_aggr_type (TREE_CODE (t));
|
2175 |
|
|
pushtag (TYPE_IDENTIFIER (t), t, /*tag_scope=*/ts_current);
|
2176 |
|
|
}
|
2177 |
|
|
maybe_process_partial_specialization (t);
|
2178 |
|
|
pushclass (t);
|
2179 |
|
|
TYPE_BEING_DEFINED (t) = 1;
|
2180 |
|
|
if (flag_pack_struct)
|
2181 |
|
|
{
|
2182 |
|
|
tree v;
|
2183 |
|
|
TYPE_PACKED (t) = 1;
|
2184 |
|
|
/* Even though the type is being defined for the first time
|
2185 |
|
|
here, there might have been a forward declaration, so there
|
2186 |
|
|
might be cv-qualified variants of T. */
|
2187 |
|
|
for (v = TYPE_NEXT_VARIANT (t); v; v = TYPE_NEXT_VARIANT (v))
|
2188 |
|
|
TYPE_PACKED (v) = 1;
|
2189 |
|
|
}
|
2190 |
|
|
/* Reset the interface data, at the earliest possible
|
2191 |
|
|
moment, as it might have been set via a class foo;
|
2192 |
|
|
before. */
|
2193 |
|
|
if (! TYPE_ANONYMOUS_P (t))
|
2194 |
|
|
{
|
2195 |
|
|
struct c_fileinfo *finfo = get_fileinfo (lbasename (input_filename));
|
2196 |
|
|
CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
|
2197 |
|
|
SET_CLASSTYPE_INTERFACE_UNKNOWN_X
|
2198 |
|
|
(t, finfo->interface_unknown);
|
2199 |
|
|
}
|
2200 |
|
|
reset_specialization();
|
2201 |
|
|
|
2202 |
|
|
/* Make a declaration for this class in its own scope. */
|
2203 |
|
|
build_self_reference ();
|
2204 |
|
|
|
2205 |
|
|
return t;
|
2206 |
|
|
}
|
2207 |
|
|
|
2208 |
|
|
/* Finish the member declaration given by DECL. */
|
2209 |
|
|
|
2210 |
|
|
void
|
2211 |
|
|
finish_member_declaration (tree decl)
|
2212 |
|
|
{
|
2213 |
|
|
if (decl == error_mark_node || decl == NULL_TREE)
|
2214 |
|
|
return;
|
2215 |
|
|
|
2216 |
|
|
if (decl == void_type_node)
|
2217 |
|
|
/* The COMPONENT was a friend, not a member, and so there's
|
2218 |
|
|
nothing for us to do. */
|
2219 |
|
|
return;
|
2220 |
|
|
|
2221 |
|
|
/* We should see only one DECL at a time. */
|
2222 |
|
|
gcc_assert (TREE_CHAIN (decl) == NULL_TREE);
|
2223 |
|
|
|
2224 |
|
|
/* Set up access control for DECL. */
|
2225 |
|
|
TREE_PRIVATE (decl)
|
2226 |
|
|
= (current_access_specifier == access_private_node);
|
2227 |
|
|
TREE_PROTECTED (decl)
|
2228 |
|
|
= (current_access_specifier == access_protected_node);
|
2229 |
|
|
if (TREE_CODE (decl) == TEMPLATE_DECL)
|
2230 |
|
|
{
|
2231 |
|
|
TREE_PRIVATE (DECL_TEMPLATE_RESULT (decl)) = TREE_PRIVATE (decl);
|
2232 |
|
|
TREE_PROTECTED (DECL_TEMPLATE_RESULT (decl)) = TREE_PROTECTED (decl);
|
2233 |
|
|
}
|
2234 |
|
|
|
2235 |
|
|
/* Mark the DECL as a member of the current class. */
|
2236 |
|
|
DECL_CONTEXT (decl) = current_class_type;
|
2237 |
|
|
|
2238 |
|
|
/* [dcl.link]
|
2239 |
|
|
|
2240 |
|
|
A C language linkage is ignored for the names of class members
|
2241 |
|
|
and the member function type of class member functions. */
|
2242 |
|
|
if (DECL_LANG_SPECIFIC (decl) && DECL_LANGUAGE (decl) == lang_c)
|
2243 |
|
|
SET_DECL_LANGUAGE (decl, lang_cplusplus);
|
2244 |
|
|
|
2245 |
|
|
/* Put functions on the TYPE_METHODS list and everything else on the
|
2246 |
|
|
TYPE_FIELDS list. Note that these are built up in reverse order.
|
2247 |
|
|
We reverse them (to obtain declaration order) in finish_struct. */
|
2248 |
|
|
if (TREE_CODE (decl) == FUNCTION_DECL
|
2249 |
|
|
|| DECL_FUNCTION_TEMPLATE_P (decl))
|
2250 |
|
|
{
|
2251 |
|
|
/* We also need to add this function to the
|
2252 |
|
|
CLASSTYPE_METHOD_VEC. */
|
2253 |
|
|
if (add_method (current_class_type, decl, NULL_TREE))
|
2254 |
|
|
{
|
2255 |
|
|
TREE_CHAIN (decl) = TYPE_METHODS (current_class_type);
|
2256 |
|
|
TYPE_METHODS (current_class_type) = decl;
|
2257 |
|
|
|
2258 |
|
|
maybe_add_class_template_decl_list (current_class_type, decl,
|
2259 |
|
|
/*friend_p=*/0);
|
2260 |
|
|
}
|
2261 |
|
|
}
|
2262 |
|
|
/* Enter the DECL into the scope of the class. */
|
2263 |
|
|
else if ((TREE_CODE (decl) == USING_DECL && !DECL_DEPENDENT_P (decl))
|
2264 |
|
|
|| pushdecl_class_level (decl))
|
2265 |
|
|
{
|
2266 |
|
|
/* All TYPE_DECLs go at the end of TYPE_FIELDS. Ordinary fields
|
2267 |
|
|
go at the beginning. The reason is that lookup_field_1
|
2268 |
|
|
searches the list in order, and we want a field name to
|
2269 |
|
|
override a type name so that the "struct stat hack" will
|
2270 |
|
|
work. In particular:
|
2271 |
|
|
|
2272 |
|
|
struct S { enum E { }; int E } s;
|
2273 |
|
|
s.E = 3;
|
2274 |
|
|
|
2275 |
|
|
is valid. In addition, the FIELD_DECLs must be maintained in
|
2276 |
|
|
declaration order so that class layout works as expected.
|
2277 |
|
|
However, we don't need that order until class layout, so we
|
2278 |
|
|
save a little time by putting FIELD_DECLs on in reverse order
|
2279 |
|
|
here, and then reversing them in finish_struct_1. (We could
|
2280 |
|
|
also keep a pointer to the correct insertion points in the
|
2281 |
|
|
list.) */
|
2282 |
|
|
|
2283 |
|
|
if (TREE_CODE (decl) == TYPE_DECL)
|
2284 |
|
|
TYPE_FIELDS (current_class_type)
|
2285 |
|
|
= chainon (TYPE_FIELDS (current_class_type), decl);
|
2286 |
|
|
else
|
2287 |
|
|
{
|
2288 |
|
|
TREE_CHAIN (decl) = TYPE_FIELDS (current_class_type);
|
2289 |
|
|
TYPE_FIELDS (current_class_type) = decl;
|
2290 |
|
|
}
|
2291 |
|
|
|
2292 |
|
|
maybe_add_class_template_decl_list (current_class_type, decl,
|
2293 |
|
|
/*friend_p=*/0);
|
2294 |
|
|
}
|
2295 |
|
|
|
2296 |
|
|
if (pch_file)
|
2297 |
|
|
note_decl_for_pch (decl);
|
2298 |
|
|
}
|
2299 |
|
|
|
2300 |
|
|
/* DECL has been declared while we are building a PCH file. Perform
|
2301 |
|
|
actions that we might normally undertake lazily, but which can be
|
2302 |
|
|
performed now so that they do not have to be performed in
|
2303 |
|
|
translation units which include the PCH file. */
|
2304 |
|
|
|
2305 |
|
|
void
|
2306 |
|
|
note_decl_for_pch (tree decl)
|
2307 |
|
|
{
|
2308 |
|
|
gcc_assert (pch_file);
|
2309 |
|
|
|
2310 |
|
|
/* There's a good chance that we'll have to mangle names at some
|
2311 |
|
|
point, even if only for emission in debugging information. */
|
2312 |
|
|
if (TREE_CODE (decl) == VAR_DECL
|
2313 |
|
|
|| TREE_CODE (decl) == FUNCTION_DECL)
|
2314 |
|
|
mangle_decl (decl);
|
2315 |
|
|
}
|
2316 |
|
|
|
2317 |
|
|
/* Finish processing a complete template declaration. The PARMS are
|
2318 |
|
|
the template parameters. */
|
2319 |
|
|
|
2320 |
|
|
void
|
2321 |
|
|
finish_template_decl (tree parms)
|
2322 |
|
|
{
|
2323 |
|
|
if (parms)
|
2324 |
|
|
end_template_decl ();
|
2325 |
|
|
else
|
2326 |
|
|
end_specialization ();
|
2327 |
|
|
}
|
2328 |
|
|
|
2329 |
|
|
/* Finish processing a template-id (which names a type) of the form
|
2330 |
|
|
NAME < ARGS >. Return the TYPE_DECL for the type named by the
|
2331 |
|
|
template-id. If ENTERING_SCOPE is nonzero we are about to enter
|
2332 |
|
|
the scope of template-id indicated. */
|
2333 |
|
|
|
2334 |
|
|
tree
|
2335 |
|
|
finish_template_type (tree name, tree args, int entering_scope)
|
2336 |
|
|
{
|
2337 |
|
|
tree decl;
|
2338 |
|
|
|
2339 |
|
|
decl = lookup_template_class (name, args,
|
2340 |
|
|
NULL_TREE, NULL_TREE, entering_scope,
|
2341 |
|
|
tf_error | tf_warning | tf_user);
|
2342 |
|
|
if (decl != error_mark_node)
|
2343 |
|
|
decl = TYPE_STUB_DECL (decl);
|
2344 |
|
|
|
2345 |
|
|
return decl;
|
2346 |
|
|
}
|
2347 |
|
|
|
2348 |
|
|
/* Finish processing a BASE_CLASS with the indicated ACCESS_SPECIFIER.
|
2349 |
|
|
Return a TREE_LIST containing the ACCESS_SPECIFIER and the
|
2350 |
|
|
BASE_CLASS, or NULL_TREE if an error occurred. The
|
2351 |
|
|
ACCESS_SPECIFIER is one of
|
2352 |
|
|
access_{default,public,protected_private}_node. For a virtual base
|
2353 |
|
|
we set TREE_TYPE. */
|
2354 |
|
|
|
2355 |
|
|
tree
|
2356 |
|
|
finish_base_specifier (tree base, tree access, bool virtual_p)
|
2357 |
|
|
{
|
2358 |
|
|
tree result;
|
2359 |
|
|
|
2360 |
|
|
if (base == error_mark_node)
|
2361 |
|
|
{
|
2362 |
|
|
error ("invalid base-class specification");
|
2363 |
|
|
result = NULL_TREE;
|
2364 |
|
|
}
|
2365 |
|
|
else if (! is_aggr_type (base, 1))
|
2366 |
|
|
result = NULL_TREE;
|
2367 |
|
|
else
|
2368 |
|
|
{
|
2369 |
|
|
if (cp_type_quals (base) != 0)
|
2370 |
|
|
{
|
2371 |
|
|
error ("base class %qT has cv qualifiers", base);
|
2372 |
|
|
base = TYPE_MAIN_VARIANT (base);
|
2373 |
|
|
}
|
2374 |
|
|
result = build_tree_list (access, base);
|
2375 |
|
|
if (virtual_p)
|
2376 |
|
|
TREE_TYPE (result) = integer_type_node;
|
2377 |
|
|
}
|
2378 |
|
|
|
2379 |
|
|
return result;
|
2380 |
|
|
}
|
2381 |
|
|
|
2382 |
|
|
/* Issue a diagnostic that NAME cannot be found in SCOPE. DECL is
|
2383 |
|
|
what we found when we tried to do the lookup. */
|
2384 |
|
|
|
2385 |
|
|
void
|
2386 |
|
|
qualified_name_lookup_error (tree scope, tree name, tree decl)
|
2387 |
|
|
{
|
2388 |
|
|
if (scope == error_mark_node)
|
2389 |
|
|
; /* We already complained. */
|
2390 |
|
|
else if (TYPE_P (scope))
|
2391 |
|
|
{
|
2392 |
|
|
if (!COMPLETE_TYPE_P (scope))
|
2393 |
|
|
error ("incomplete type %qT used in nested name specifier", scope);
|
2394 |
|
|
else if (TREE_CODE (decl) == TREE_LIST)
|
2395 |
|
|
{
|
2396 |
|
|
error ("reference to %<%T::%D%> is ambiguous", scope, name);
|
2397 |
|
|
print_candidates (decl);
|
2398 |
|
|
}
|
2399 |
|
|
else
|
2400 |
|
|
error ("%qD is not a member of %qT", name, scope);
|
2401 |
|
|
}
|
2402 |
|
|
else if (scope != global_namespace)
|
2403 |
|
|
error ("%qD is not a member of %qD", name, scope);
|
2404 |
|
|
else
|
2405 |
|
|
error ("%<::%D%> has not been declared", name);
|
2406 |
|
|
}
|
2407 |
|
|
|
2408 |
|
|
/* ID_EXPRESSION is a representation of parsed, but unprocessed,
|
2409 |
|
|
id-expression. (See cp_parser_id_expression for details.) SCOPE,
|
2410 |
|
|
if non-NULL, is the type or namespace used to explicitly qualify
|
2411 |
|
|
ID_EXPRESSION. DECL is the entity to which that name has been
|
2412 |
|
|
resolved.
|
2413 |
|
|
|
2414 |
|
|
*CONSTANT_EXPRESSION_P is true if we are presently parsing a
|
2415 |
|
|
constant-expression. In that case, *NON_CONSTANT_EXPRESSION_P will
|
2416 |
|
|
be set to true if this expression isn't permitted in a
|
2417 |
|
|
constant-expression, but it is otherwise not set by this function.
|
2418 |
|
|
*ALLOW_NON_CONSTANT_EXPRESSION_P is true if we are parsing a
|
2419 |
|
|
constant-expression, but a non-constant expression is also
|
2420 |
|
|
permissible.
|
2421 |
|
|
|
2422 |
|
|
DONE is true if this expression is a complete postfix-expression;
|
2423 |
|
|
it is false if this expression is followed by '->', '[', '(', etc.
|
2424 |
|
|
ADDRESS_P is true iff this expression is the operand of '&'.
|
2425 |
|
|
TEMPLATE_P is true iff the qualified-id was of the form
|
2426 |
|
|
"A::template B". TEMPLATE_ARG_P is true iff this qualified name
|
2427 |
|
|
appears as a template argument.
|
2428 |
|
|
|
2429 |
|
|
If an error occurs, and it is the kind of error that might cause
|
2430 |
|
|
the parser to abort a tentative parse, *ERROR_MSG is filled in. It
|
2431 |
|
|
is the caller's responsibility to issue the message. *ERROR_MSG
|
2432 |
|
|
will be a string with static storage duration, so the caller need
|
2433 |
|
|
not "free" it.
|
2434 |
|
|
|
2435 |
|
|
Return an expression for the entity, after issuing appropriate
|
2436 |
|
|
diagnostics. This function is also responsible for transforming a
|
2437 |
|
|
reference to a non-static member into a COMPONENT_REF that makes
|
2438 |
|
|
the use of "this" explicit.
|
2439 |
|
|
|
2440 |
|
|
Upon return, *IDK will be filled in appropriately. */
|
2441 |
|
|
|
2442 |
|
|
tree
|
2443 |
|
|
finish_id_expression (tree id_expression,
|
2444 |
|
|
tree decl,
|
2445 |
|
|
tree scope,
|
2446 |
|
|
cp_id_kind *idk,
|
2447 |
|
|
bool integral_constant_expression_p,
|
2448 |
|
|
bool allow_non_integral_constant_expression_p,
|
2449 |
|
|
bool *non_integral_constant_expression_p,
|
2450 |
|
|
bool template_p,
|
2451 |
|
|
bool done,
|
2452 |
|
|
bool address_p,
|
2453 |
|
|
bool template_arg_p,
|
2454 |
|
|
const char **error_msg)
|
2455 |
|
|
{
|
2456 |
|
|
/* Initialize the output parameters. */
|
2457 |
|
|
*idk = CP_ID_KIND_NONE;
|
2458 |
|
|
*error_msg = NULL;
|
2459 |
|
|
|
2460 |
|
|
if (id_expression == error_mark_node)
|
2461 |
|
|
return error_mark_node;
|
2462 |
|
|
/* If we have a template-id, then no further lookup is
|
2463 |
|
|
required. If the template-id was for a template-class, we
|
2464 |
|
|
will sometimes have a TYPE_DECL at this point. */
|
2465 |
|
|
else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
|
2466 |
|
|
|| TREE_CODE (decl) == TYPE_DECL)
|
2467 |
|
|
;
|
2468 |
|
|
/* Look up the name. */
|
2469 |
|
|
else
|
2470 |
|
|
{
|
2471 |
|
|
if (decl == error_mark_node)
|
2472 |
|
|
{
|
2473 |
|
|
/* Name lookup failed. */
|
2474 |
|
|
if (scope
|
2475 |
|
|
&& (!TYPE_P (scope)
|
2476 |
|
|
|| (!dependent_type_p (scope)
|
2477 |
|
|
&& !(TREE_CODE (id_expression) == IDENTIFIER_NODE
|
2478 |
|
|
&& IDENTIFIER_TYPENAME_P (id_expression)
|
2479 |
|
|
&& dependent_type_p (TREE_TYPE (id_expression))))))
|
2480 |
|
|
{
|
2481 |
|
|
/* If the qualifying type is non-dependent (and the name
|
2482 |
|
|
does not name a conversion operator to a dependent
|
2483 |
|
|
type), issue an error. */
|
2484 |
|
|
qualified_name_lookup_error (scope, id_expression, decl);
|
2485 |
|
|
return error_mark_node;
|
2486 |
|
|
}
|
2487 |
|
|
else if (!scope)
|
2488 |
|
|
{
|
2489 |
|
|
/* It may be resolved via Koenig lookup. */
|
2490 |
|
|
*idk = CP_ID_KIND_UNQUALIFIED;
|
2491 |
|
|
return id_expression;
|
2492 |
|
|
}
|
2493 |
|
|
else
|
2494 |
|
|
decl = id_expression;
|
2495 |
|
|
}
|
2496 |
|
|
/* If DECL is a variable that would be out of scope under
|
2497 |
|
|
ANSI/ISO rules, but in scope in the ARM, name lookup
|
2498 |
|
|
will succeed. Issue a diagnostic here. */
|
2499 |
|
|
else
|
2500 |
|
|
decl = check_for_out_of_scope_variable (decl);
|
2501 |
|
|
|
2502 |
|
|
/* Remember that the name was used in the definition of
|
2503 |
|
|
the current class so that we can check later to see if
|
2504 |
|
|
the meaning would have been different after the class
|
2505 |
|
|
was entirely defined. */
|
2506 |
|
|
if (!scope && decl != error_mark_node)
|
2507 |
|
|
maybe_note_name_used_in_class (id_expression, decl);
|
2508 |
|
|
|
2509 |
|
|
/* Disallow uses of local variables from containing functions. */
|
2510 |
|
|
if (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL)
|
2511 |
|
|
{
|
2512 |
|
|
tree context = decl_function_context (decl);
|
2513 |
|
|
if (context != NULL_TREE && context != current_function_decl
|
2514 |
|
|
&& ! TREE_STATIC (decl))
|
2515 |
|
|
{
|
2516 |
|
|
error (TREE_CODE (decl) == VAR_DECL
|
2517 |
|
|
? "use of %<auto%> variable from containing function"
|
2518 |
|
|
: "use of parameter from containing function");
|
2519 |
|
|
error (" %q+#D declared here", decl);
|
2520 |
|
|
return error_mark_node;
|
2521 |
|
|
}
|
2522 |
|
|
}
|
2523 |
|
|
}
|
2524 |
|
|
|
2525 |
|
|
/* If we didn't find anything, or what we found was a type,
|
2526 |
|
|
then this wasn't really an id-expression. */
|
2527 |
|
|
if (TREE_CODE (decl) == TEMPLATE_DECL
|
2528 |
|
|
&& !DECL_FUNCTION_TEMPLATE_P (decl))
|
2529 |
|
|
{
|
2530 |
|
|
*error_msg = "missing template arguments";
|
2531 |
|
|
return error_mark_node;
|
2532 |
|
|
}
|
2533 |
|
|
else if (TREE_CODE (decl) == TYPE_DECL
|
2534 |
|
|
|| TREE_CODE (decl) == NAMESPACE_DECL)
|
2535 |
|
|
{
|
2536 |
|
|
*error_msg = "expected primary-expression";
|
2537 |
|
|
return error_mark_node;
|
2538 |
|
|
}
|
2539 |
|
|
|
2540 |
|
|
/* If the name resolved to a template parameter, there is no
|
2541 |
|
|
need to look it up again later. */
|
2542 |
|
|
if ((TREE_CODE (decl) == CONST_DECL && DECL_TEMPLATE_PARM_P (decl))
|
2543 |
|
|
|| TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
|
2544 |
|
|
{
|
2545 |
|
|
tree r;
|
2546 |
|
|
|
2547 |
|
|
*idk = CP_ID_KIND_NONE;
|
2548 |
|
|
if (TREE_CODE (decl) == TEMPLATE_PARM_INDEX)
|
2549 |
|
|
decl = TEMPLATE_PARM_DECL (decl);
|
2550 |
|
|
r = convert_from_reference (DECL_INITIAL (decl));
|
2551 |
|
|
|
2552 |
|
|
if (integral_constant_expression_p
|
2553 |
|
|
&& !dependent_type_p (TREE_TYPE (decl))
|
2554 |
|
|
&& !(INTEGRAL_OR_ENUMERATION_TYPE_P (TREE_TYPE (r))))
|
2555 |
|
|
{
|
2556 |
|
|
if (!allow_non_integral_constant_expression_p)
|
2557 |
|
|
error ("template parameter %qD of type %qT is not allowed in "
|
2558 |
|
|
"an integral constant expression because it is not of "
|
2559 |
|
|
"integral or enumeration type", decl, TREE_TYPE (decl));
|
2560 |
|
|
*non_integral_constant_expression_p = true;
|
2561 |
|
|
}
|
2562 |
|
|
return r;
|
2563 |
|
|
}
|
2564 |
|
|
/* Similarly, we resolve enumeration constants to their
|
2565 |
|
|
underlying values. */
|
2566 |
|
|
else if (TREE_CODE (decl) == CONST_DECL)
|
2567 |
|
|
{
|
2568 |
|
|
*idk = CP_ID_KIND_NONE;
|
2569 |
|
|
if (!processing_template_decl)
|
2570 |
|
|
return DECL_INITIAL (decl);
|
2571 |
|
|
return decl;
|
2572 |
|
|
}
|
2573 |
|
|
else
|
2574 |
|
|
{
|
2575 |
|
|
bool dependent_p;
|
2576 |
|
|
|
2577 |
|
|
/* If the declaration was explicitly qualified indicate
|
2578 |
|
|
that. The semantics of `A::f(3)' are different than
|
2579 |
|
|
`f(3)' if `f' is virtual. */
|
2580 |
|
|
*idk = (scope
|
2581 |
|
|
? CP_ID_KIND_QUALIFIED
|
2582 |
|
|
: (TREE_CODE (decl) == TEMPLATE_ID_EXPR
|
2583 |
|
|
? CP_ID_KIND_TEMPLATE_ID
|
2584 |
|
|
: CP_ID_KIND_UNQUALIFIED));
|
2585 |
|
|
|
2586 |
|
|
|
2587 |
|
|
/* [temp.dep.expr]
|
2588 |
|
|
|
2589 |
|
|
An id-expression is type-dependent if it contains an
|
2590 |
|
|
identifier that was declared with a dependent type.
|
2591 |
|
|
|
2592 |
|
|
The standard is not very specific about an id-expression that
|
2593 |
|
|
names a set of overloaded functions. What if some of them
|
2594 |
|
|
have dependent types and some of them do not? Presumably,
|
2595 |
|
|
such a name should be treated as a dependent name. */
|
2596 |
|
|
/* Assume the name is not dependent. */
|
2597 |
|
|
dependent_p = false;
|
2598 |
|
|
if (!processing_template_decl)
|
2599 |
|
|
/* No names are dependent outside a template. */
|
2600 |
|
|
;
|
2601 |
|
|
/* A template-id where the name of the template was not resolved
|
2602 |
|
|
is definitely dependent. */
|
2603 |
|
|
else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR
|
2604 |
|
|
&& (TREE_CODE (TREE_OPERAND (decl, 0))
|
2605 |
|
|
== IDENTIFIER_NODE))
|
2606 |
|
|
dependent_p = true;
|
2607 |
|
|
/* For anything except an overloaded function, just check its
|
2608 |
|
|
type. */
|
2609 |
|
|
else if (!is_overloaded_fn (decl))
|
2610 |
|
|
dependent_p
|
2611 |
|
|
= dependent_type_p (TREE_TYPE (decl));
|
2612 |
|
|
/* For a set of overloaded functions, check each of the
|
2613 |
|
|
functions. */
|
2614 |
|
|
else
|
2615 |
|
|
{
|
2616 |
|
|
tree fns = decl;
|
2617 |
|
|
|
2618 |
|
|
if (BASELINK_P (fns))
|
2619 |
|
|
fns = BASELINK_FUNCTIONS (fns);
|
2620 |
|
|
|
2621 |
|
|
/* For a template-id, check to see if the template
|
2622 |
|
|
arguments are dependent. */
|
2623 |
|
|
if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
|
2624 |
|
|
{
|
2625 |
|
|
tree args = TREE_OPERAND (fns, 1);
|
2626 |
|
|
dependent_p = any_dependent_template_arguments_p (args);
|
2627 |
|
|
/* The functions are those referred to by the
|
2628 |
|
|
template-id. */
|
2629 |
|
|
fns = TREE_OPERAND (fns, 0);
|
2630 |
|
|
}
|
2631 |
|
|
|
2632 |
|
|
/* If there are no dependent template arguments, go through
|
2633 |
|
|
the overloaded functions. */
|
2634 |
|
|
while (fns && !dependent_p)
|
2635 |
|
|
{
|
2636 |
|
|
tree fn = OVL_CURRENT (fns);
|
2637 |
|
|
|
2638 |
|
|
/* Member functions of dependent classes are
|
2639 |
|
|
dependent. */
|
2640 |
|
|
if (TREE_CODE (fn) == FUNCTION_DECL
|
2641 |
|
|
&& type_dependent_expression_p (fn))
|
2642 |
|
|
dependent_p = true;
|
2643 |
|
|
else if (TREE_CODE (fn) == TEMPLATE_DECL
|
2644 |
|
|
&& dependent_template_p (fn))
|
2645 |
|
|
dependent_p = true;
|
2646 |
|
|
|
2647 |
|
|
fns = OVL_NEXT (fns);
|
2648 |
|
|
}
|
2649 |
|
|
}
|
2650 |
|
|
|
2651 |
|
|
/* If the name was dependent on a template parameter, we will
|
2652 |
|
|
resolve the name at instantiation time. */
|
2653 |
|
|
if (dependent_p)
|
2654 |
|
|
{
|
2655 |
|
|
/* Create a SCOPE_REF for qualified names, if the scope is
|
2656 |
|
|
dependent. */
|
2657 |
|
|
if (scope)
|
2658 |
|
|
{
|
2659 |
|
|
/* Since this name was dependent, the expression isn't
|
2660 |
|
|
constant -- yet. No error is issued because it might
|
2661 |
|
|
be constant when things are instantiated. */
|
2662 |
|
|
if (integral_constant_expression_p)
|
2663 |
|
|
*non_integral_constant_expression_p = true;
|
2664 |
|
|
if (TYPE_P (scope))
|
2665 |
|
|
{
|
2666 |
|
|
if (address_p && done)
|
2667 |
|
|
decl = finish_qualified_id_expr (scope, decl,
|
2668 |
|
|
done, address_p,
|
2669 |
|
|
template_p,
|
2670 |
|
|
template_arg_p);
|
2671 |
|
|
else if (dependent_type_p (scope))
|
2672 |
|
|
decl = build_qualified_name (/*type=*/NULL_TREE,
|
2673 |
|
|
scope,
|
2674 |
|
|
id_expression,
|
2675 |
|
|
template_p);
|
2676 |
|
|
else if (DECL_P (decl))
|
2677 |
|
|
decl = build_qualified_name (TREE_TYPE (decl),
|
2678 |
|
|
scope,
|
2679 |
|
|
id_expression,
|
2680 |
|
|
template_p);
|
2681 |
|
|
}
|
2682 |
|
|
if (TREE_TYPE (decl))
|
2683 |
|
|
decl = convert_from_reference (decl);
|
2684 |
|
|
return decl;
|
2685 |
|
|
}
|
2686 |
|
|
/* A TEMPLATE_ID already contains all the information we
|
2687 |
|
|
need. */
|
2688 |
|
|
if (TREE_CODE (id_expression) == TEMPLATE_ID_EXPR)
|
2689 |
|
|
return id_expression;
|
2690 |
|
|
*idk = CP_ID_KIND_UNQUALIFIED_DEPENDENT;
|
2691 |
|
|
/* If we found a variable, then name lookup during the
|
2692 |
|
|
instantiation will always resolve to the same VAR_DECL
|
2693 |
|
|
(or an instantiation thereof). */
|
2694 |
|
|
if (TREE_CODE (decl) == VAR_DECL
|
2695 |
|
|
|| TREE_CODE (decl) == PARM_DECL)
|
2696 |
|
|
return convert_from_reference (decl);
|
2697 |
|
|
/* The same is true for FIELD_DECL, but we also need to
|
2698 |
|
|
make sure that the syntax is correct. */
|
2699 |
|
|
else if (TREE_CODE (decl) == FIELD_DECL)
|
2700 |
|
|
{
|
2701 |
|
|
/* Since SCOPE is NULL here, this is an unqualified name.
|
2702 |
|
|
Access checking has been performed during name lookup
|
2703 |
|
|
already. Turn off checking to avoid duplicate errors. */
|
2704 |
|
|
push_deferring_access_checks (dk_no_check);
|
2705 |
|
|
decl = finish_non_static_data_member
|
2706 |
|
|
(decl, current_class_ref,
|
2707 |
|
|
/*qualifying_scope=*/NULL_TREE);
|
2708 |
|
|
pop_deferring_access_checks ();
|
2709 |
|
|
return decl;
|
2710 |
|
|
}
|
2711 |
|
|
return id_expression;
|
2712 |
|
|
}
|
2713 |
|
|
|
2714 |
|
|
/* Only certain kinds of names are allowed in constant
|
2715 |
|
|
expression. Enumerators and template parameters have already
|
2716 |
|
|
been handled above. */
|
2717 |
|
|
if (integral_constant_expression_p
|
2718 |
|
|
&& ! DECL_INTEGRAL_CONSTANT_VAR_P (decl)
|
2719 |
|
|
&& ! builtin_valid_in_constant_expr_p (decl))
|
2720 |
|
|
{
|
2721 |
|
|
if (!allow_non_integral_constant_expression_p)
|
2722 |
|
|
{
|
2723 |
|
|
error ("%qD cannot appear in a constant-expression", decl);
|
2724 |
|
|
return error_mark_node;
|
2725 |
|
|
}
|
2726 |
|
|
*non_integral_constant_expression_p = true;
|
2727 |
|
|
}
|
2728 |
|
|
|
2729 |
|
|
if (TREE_CODE (decl) == NAMESPACE_DECL)
|
2730 |
|
|
{
|
2731 |
|
|
error ("use of namespace %qD as expression", decl);
|
2732 |
|
|
return error_mark_node;
|
2733 |
|
|
}
|
2734 |
|
|
else if (DECL_CLASS_TEMPLATE_P (decl))
|
2735 |
|
|
{
|
2736 |
|
|
error ("use of class template %qT as expression", decl);
|
2737 |
|
|
return error_mark_node;
|
2738 |
|
|
}
|
2739 |
|
|
else if (TREE_CODE (decl) == TREE_LIST)
|
2740 |
|
|
{
|
2741 |
|
|
/* Ambiguous reference to base members. */
|
2742 |
|
|
error ("request for member %qD is ambiguous in "
|
2743 |
|
|
"multiple inheritance lattice", id_expression);
|
2744 |
|
|
print_candidates (decl);
|
2745 |
|
|
return error_mark_node;
|
2746 |
|
|
}
|
2747 |
|
|
|
2748 |
|
|
/* Mark variable-like entities as used. Functions are similarly
|
2749 |
|
|
marked either below or after overload resolution. */
|
2750 |
|
|
if (TREE_CODE (decl) == VAR_DECL
|
2751 |
|
|
|| TREE_CODE (decl) == PARM_DECL
|
2752 |
|
|
|| TREE_CODE (decl) == RESULT_DECL)
|
2753 |
|
|
mark_used (decl);
|
2754 |
|
|
|
2755 |
|
|
if (scope)
|
2756 |
|
|
{
|
2757 |
|
|
decl = (adjust_result_of_qualified_name_lookup
|
2758 |
|
|
(decl, scope, current_class_type));
|
2759 |
|
|
|
2760 |
|
|
if (TREE_CODE (decl) == FUNCTION_DECL)
|
2761 |
|
|
mark_used (decl);
|
2762 |
|
|
|
2763 |
|
|
if (TREE_CODE (decl) == FIELD_DECL || BASELINK_P (decl))
|
2764 |
|
|
decl = finish_qualified_id_expr (scope,
|
2765 |
|
|
decl,
|
2766 |
|
|
done,
|
2767 |
|
|
address_p,
|
2768 |
|
|
template_p,
|
2769 |
|
|
template_arg_p);
|
2770 |
|
|
else
|
2771 |
|
|
{
|
2772 |
|
|
tree r = convert_from_reference (decl);
|
2773 |
|
|
|
2774 |
|
|
if (processing_template_decl && TYPE_P (scope))
|
2775 |
|
|
r = build_qualified_name (TREE_TYPE (r),
|
2776 |
|
|
scope, decl,
|
2777 |
|
|
template_p);
|
2778 |
|
|
decl = r;
|
2779 |
|
|
}
|
2780 |
|
|
}
|
2781 |
|
|
else if (TREE_CODE (decl) == FIELD_DECL)
|
2782 |
|
|
{
|
2783 |
|
|
/* Since SCOPE is NULL here, this is an unqualified name.
|
2784 |
|
|
Access checking has been performed during name lookup
|
2785 |
|
|
already. Turn off checking to avoid duplicate errors. */
|
2786 |
|
|
push_deferring_access_checks (dk_no_check);
|
2787 |
|
|
decl = finish_non_static_data_member (decl, current_class_ref,
|
2788 |
|
|
/*qualifying_scope=*/NULL_TREE);
|
2789 |
|
|
pop_deferring_access_checks ();
|
2790 |
|
|
}
|
2791 |
|
|
else if (is_overloaded_fn (decl))
|
2792 |
|
|
{
|
2793 |
|
|
tree first_fn = OVL_CURRENT (decl);
|
2794 |
|
|
|
2795 |
|
|
if (TREE_CODE (first_fn) == TEMPLATE_DECL)
|
2796 |
|
|
first_fn = DECL_TEMPLATE_RESULT (first_fn);
|
2797 |
|
|
|
2798 |
|
|
if (!really_overloaded_fn (decl))
|
2799 |
|
|
mark_used (first_fn);
|
2800 |
|
|
|
2801 |
|
|
if (!template_arg_p
|
2802 |
|
|
&& TREE_CODE (first_fn) == FUNCTION_DECL
|
2803 |
|
|
&& DECL_FUNCTION_MEMBER_P (first_fn)
|
2804 |
|
|
&& !shared_member_p (decl))
|
2805 |
|
|
{
|
2806 |
|
|
/* A set of member functions. */
|
2807 |
|
|
decl = maybe_dummy_object (DECL_CONTEXT (first_fn), 0);
|
2808 |
|
|
return finish_class_member_access_expr (decl, id_expression,
|
2809 |
|
|
/*template_p=*/false);
|
2810 |
|
|
}
|
2811 |
|
|
}
|
2812 |
|
|
else
|
2813 |
|
|
{
|
2814 |
|
|
if (DECL_P (decl) && DECL_NONLOCAL (decl)
|
2815 |
|
|
&& DECL_CLASS_SCOPE_P (decl)
|
2816 |
|
|
&& DECL_CONTEXT (decl) != current_class_type)
|
2817 |
|
|
{
|
2818 |
|
|
tree path;
|
2819 |
|
|
|
2820 |
|
|
path = currently_open_derived_class (DECL_CONTEXT (decl));
|
2821 |
|
|
perform_or_defer_access_check (TYPE_BINFO (path), decl);
|
2822 |
|
|
}
|
2823 |
|
|
|
2824 |
|
|
decl = convert_from_reference (decl);
|
2825 |
|
|
}
|
2826 |
|
|
}
|
2827 |
|
|
|
2828 |
|
|
if (TREE_DEPRECATED (decl))
|
2829 |
|
|
warn_deprecated_use (decl);
|
2830 |
|
|
|
2831 |
|
|
return decl;
|
2832 |
|
|
}
|
2833 |
|
|
|
2834 |
|
|
/* Implement the __typeof keyword: Return the type of EXPR, suitable for
|
2835 |
|
|
use as a type-specifier. */
|
2836 |
|
|
|
2837 |
|
|
tree
|
2838 |
|
|
finish_typeof (tree expr)
|
2839 |
|
|
{
|
2840 |
|
|
tree type;
|
2841 |
|
|
|
2842 |
|
|
if (type_dependent_expression_p (expr))
|
2843 |
|
|
{
|
2844 |
|
|
type = make_aggr_type (TYPEOF_TYPE);
|
2845 |
|
|
TYPEOF_TYPE_EXPR (type) = expr;
|
2846 |
|
|
|
2847 |
|
|
return type;
|
2848 |
|
|
}
|
2849 |
|
|
|
2850 |
|
|
type = TREE_TYPE (expr);
|
2851 |
|
|
|
2852 |
|
|
if (!type || type == unknown_type_node)
|
2853 |
|
|
{
|
2854 |
|
|
error ("type of %qE is unknown", expr);
|
2855 |
|
|
return error_mark_node;
|
2856 |
|
|
}
|
2857 |
|
|
|
2858 |
|
|
return type;
|
2859 |
|
|
}
|
2860 |
|
|
|
2861 |
|
|
/* Called from expand_body via walk_tree. Replace all AGGR_INIT_EXPRs
|
2862 |
|
|
with equivalent CALL_EXPRs. */
|
2863 |
|
|
|
2864 |
|
|
static tree
|
2865 |
|
|
simplify_aggr_init_exprs_r (tree* tp,
|
2866 |
|
|
int* walk_subtrees,
|
2867 |
|
|
void* data ATTRIBUTE_UNUSED)
|
2868 |
|
|
{
|
2869 |
|
|
/* We don't need to walk into types; there's nothing in a type that
|
2870 |
|
|
needs simplification. (And, furthermore, there are places we
|
2871 |
|
|
actively don't want to go. For example, we don't want to wander
|
2872 |
|
|
into the default arguments for a FUNCTION_DECL that appears in a
|
2873 |
|
|
CALL_EXPR.) */
|
2874 |
|
|
if (TYPE_P (*tp))
|
2875 |
|
|
{
|
2876 |
|
|
*walk_subtrees = 0;
|
2877 |
|
|
return NULL_TREE;
|
2878 |
|
|
}
|
2879 |
|
|
/* Only AGGR_INIT_EXPRs are interesting. */
|
2880 |
|
|
else if (TREE_CODE (*tp) != AGGR_INIT_EXPR)
|
2881 |
|
|
return NULL_TREE;
|
2882 |
|
|
|
2883 |
|
|
simplify_aggr_init_expr (tp);
|
2884 |
|
|
|
2885 |
|
|
/* Keep iterating. */
|
2886 |
|
|
return NULL_TREE;
|
2887 |
|
|
}
|
2888 |
|
|
|
2889 |
|
|
/* Replace the AGGR_INIT_EXPR at *TP with an equivalent CALL_EXPR. This
|
2890 |
|
|
function is broken out from the above for the benefit of the tree-ssa
|
2891 |
|
|
project. */
|
2892 |
|
|
|
2893 |
|
|
void
|
2894 |
|
|
simplify_aggr_init_expr (tree *tp)
|
2895 |
|
|
{
|
2896 |
|
|
tree aggr_init_expr = *tp;
|
2897 |
|
|
|
2898 |
|
|
/* Form an appropriate CALL_EXPR. */
|
2899 |
|
|
tree fn = TREE_OPERAND (aggr_init_expr, 0);
|
2900 |
|
|
tree args = TREE_OPERAND (aggr_init_expr, 1);
|
2901 |
|
|
tree slot = TREE_OPERAND (aggr_init_expr, 2);
|
2902 |
|
|
tree type = TREE_TYPE (slot);
|
2903 |
|
|
|
2904 |
|
|
tree call_expr;
|
2905 |
|
|
enum style_t { ctor, arg, pcc } style;
|
2906 |
|
|
|
2907 |
|
|
if (AGGR_INIT_VIA_CTOR_P (aggr_init_expr))
|
2908 |
|
|
style = ctor;
|
2909 |
|
|
#ifdef PCC_STATIC_STRUCT_RETURN
|
2910 |
|
|
else if (1)
|
2911 |
|
|
style = pcc;
|
2912 |
|
|
#endif
|
2913 |
|
|
else
|
2914 |
|
|
{
|
2915 |
|
|
gcc_assert (TREE_ADDRESSABLE (type));
|
2916 |
|
|
style = arg;
|
2917 |
|
|
}
|
2918 |
|
|
|
2919 |
|
|
if (style == ctor)
|
2920 |
|
|
{
|
2921 |
|
|
/* Replace the first argument to the ctor with the address of the
|
2922 |
|
|
slot. */
|
2923 |
|
|
tree addr;
|
2924 |
|
|
|
2925 |
|
|
args = TREE_CHAIN (args);
|
2926 |
|
|
cxx_mark_addressable (slot);
|
2927 |
|
|
addr = build1 (ADDR_EXPR, build_pointer_type (type), slot);
|
2928 |
|
|
args = tree_cons (NULL_TREE, addr, args);
|
2929 |
|
|
}
|
2930 |
|
|
|
2931 |
|
|
call_expr = build3 (CALL_EXPR,
|
2932 |
|
|
TREE_TYPE (TREE_TYPE (TREE_TYPE (fn))),
|
2933 |
|
|
fn, args, NULL_TREE);
|
2934 |
|
|
|
2935 |
|
|
if (style == arg)
|
2936 |
|
|
{
|
2937 |
|
|
/* Just mark it addressable here, and leave the rest to
|
2938 |
|
|
expand_call{,_inline}. */
|
2939 |
|
|
cxx_mark_addressable (slot);
|
2940 |
|
|
CALL_EXPR_RETURN_SLOT_OPT (call_expr) = true;
|
2941 |
|
|
call_expr = build2 (MODIFY_EXPR, TREE_TYPE (call_expr), slot, call_expr);
|
2942 |
|
|
}
|
2943 |
|
|
else if (style == pcc)
|
2944 |
|
|
{
|
2945 |
|
|
/* If we're using the non-reentrant PCC calling convention, then we
|
2946 |
|
|
need to copy the returned value out of the static buffer into the
|
2947 |
|
|
SLOT. */
|
2948 |
|
|
push_deferring_access_checks (dk_no_check);
|
2949 |
|
|
call_expr = build_aggr_init (slot, call_expr,
|
2950 |
|
|
DIRECT_BIND | LOOKUP_ONLYCONVERTING);
|
2951 |
|
|
pop_deferring_access_checks ();
|
2952 |
|
|
call_expr = build (COMPOUND_EXPR, TREE_TYPE (slot), call_expr, slot);
|
2953 |
|
|
}
|
2954 |
|
|
|
2955 |
|
|
*tp = call_expr;
|
2956 |
|
|
}
|
2957 |
|
|
|
2958 |
|
|
/* Emit all thunks to FN that should be emitted when FN is emitted. */
|
2959 |
|
|
|
2960 |
|
|
static void
|
2961 |
|
|
emit_associated_thunks (tree fn)
|
2962 |
|
|
{
|
2963 |
|
|
/* When we use vcall offsets, we emit thunks with the virtual
|
2964 |
|
|
functions to which they thunk. The whole point of vcall offsets
|
2965 |
|
|
is so that you can know statically the entire set of thunks that
|
2966 |
|
|
will ever be needed for a given virtual function, thereby
|
2967 |
|
|
enabling you to output all the thunks with the function itself. */
|
2968 |
|
|
if (DECL_VIRTUAL_P (fn))
|
2969 |
|
|
{
|
2970 |
|
|
tree thunk;
|
2971 |
|
|
|
2972 |
|
|
for (thunk = DECL_THUNKS (fn); thunk; thunk = TREE_CHAIN (thunk))
|
2973 |
|
|
{
|
2974 |
|
|
if (!THUNK_ALIAS (thunk))
|
2975 |
|
|
{
|
2976 |
|
|
use_thunk (thunk, /*emit_p=*/1);
|
2977 |
|
|
if (DECL_RESULT_THUNK_P (thunk))
|
2978 |
|
|
{
|
2979 |
|
|
tree probe;
|
2980 |
|
|
|
2981 |
|
|
for (probe = DECL_THUNKS (thunk);
|
2982 |
|
|
probe; probe = TREE_CHAIN (probe))
|
2983 |
|
|
use_thunk (probe, /*emit_p=*/1);
|
2984 |
|
|
}
|
2985 |
|
|
}
|
2986 |
|
|
else
|
2987 |
|
|
gcc_assert (!DECL_THUNKS (thunk));
|
2988 |
|
|
}
|
2989 |
|
|
}
|
2990 |
|
|
}
|
2991 |
|
|
|
2992 |
|
|
/* Generate RTL for FN. */
|
2993 |
|
|
|
2994 |
|
|
void
|
2995 |
|
|
expand_body (tree fn)
|
2996 |
|
|
{
|
2997 |
|
|
tree saved_function;
|
2998 |
|
|
|
2999 |
|
|
/* Compute the appropriate object-file linkage for inline
|
3000 |
|
|
functions. */
|
3001 |
|
|
if (DECL_DECLARED_INLINE_P (fn))
|
3002 |
|
|
import_export_decl (fn);
|
3003 |
|
|
|
3004 |
|
|
/* If FN is external, then there's no point in generating RTL for
|
3005 |
|
|
it. This situation can arise with an inline function under
|
3006 |
|
|
`-fexternal-templates'; we instantiate the function, even though
|
3007 |
|
|
we're not planning on emitting it, in case we get a chance to
|
3008 |
|
|
inline it. */
|
3009 |
|
|
if (DECL_EXTERNAL (fn))
|
3010 |
|
|
return;
|
3011 |
|
|
|
3012 |
|
|
/* ??? When is this needed? */
|
3013 |
|
|
saved_function = current_function_decl;
|
3014 |
|
|
|
3015 |
|
|
/* Emit any thunks that should be emitted at the same time as FN. */
|
3016 |
|
|
emit_associated_thunks (fn);
|
3017 |
|
|
|
3018 |
|
|
/* This function is only called from cgraph, or recursively from
|
3019 |
|
|
emit_associated_thunks. In neither case should we be currently
|
3020 |
|
|
generating trees for a function. */
|
3021 |
|
|
gcc_assert (function_depth == 0);
|
3022 |
|
|
|
3023 |
|
|
tree_rest_of_compilation (fn);
|
3024 |
|
|
|
3025 |
|
|
current_function_decl = saved_function;
|
3026 |
|
|
|
3027 |
|
|
if (DECL_CLONED_FUNCTION_P (fn))
|
3028 |
|
|
{
|
3029 |
|
|
/* If this is a clone, go through the other clones now and mark
|
3030 |
|
|
their parameters used. We have to do that here, as we don't
|
3031 |
|
|
know whether any particular clone will be expanded, and
|
3032 |
|
|
therefore cannot pick one arbitrarily. */
|
3033 |
|
|
tree probe;
|
3034 |
|
|
|
3035 |
|
|
for (probe = TREE_CHAIN (DECL_CLONED_FUNCTION (fn));
|
3036 |
|
|
probe && DECL_CLONED_FUNCTION_P (probe);
|
3037 |
|
|
probe = TREE_CHAIN (probe))
|
3038 |
|
|
{
|
3039 |
|
|
tree parms;
|
3040 |
|
|
|
3041 |
|
|
for (parms = DECL_ARGUMENTS (probe);
|
3042 |
|
|
parms; parms = TREE_CHAIN (parms))
|
3043 |
|
|
TREE_USED (parms) = 1;
|
3044 |
|
|
}
|
3045 |
|
|
}
|
3046 |
|
|
}
|
3047 |
|
|
|
3048 |
|
|
/* Generate RTL for FN. */
|
3049 |
|
|
|
3050 |
|
|
void
|
3051 |
|
|
expand_or_defer_fn (tree fn)
|
3052 |
|
|
{
|
3053 |
|
|
/* When the parser calls us after finishing the body of a template
|
3054 |
|
|
function, we don't really want to expand the body. */
|
3055 |
|
|
if (processing_template_decl)
|
3056 |
|
|
{
|
3057 |
|
|
/* Normally, collection only occurs in rest_of_compilation. So,
|
3058 |
|
|
if we don't collect here, we never collect junk generated
|
3059 |
|
|
during the processing of templates until we hit a
|
3060 |
|
|
non-template function. It's not safe to do this inside a
|
3061 |
|
|
nested class, though, as the parser may have local state that
|
3062 |
|
|
is not a GC root. */
|
3063 |
|
|
if (!function_depth)
|
3064 |
|
|
ggc_collect ();
|
3065 |
|
|
return;
|
3066 |
|
|
}
|
3067 |
|
|
|
3068 |
|
|
/* Replace AGGR_INIT_EXPRs with appropriate CALL_EXPRs. */
|
3069 |
|
|
walk_tree_without_duplicates (&DECL_SAVED_TREE (fn),
|
3070 |
|
|
simplify_aggr_init_exprs_r,
|
3071 |
|
|
NULL);
|
3072 |
|
|
|
3073 |
|
|
/* If this is a constructor or destructor body, we have to clone
|
3074 |
|
|
it. */
|
3075 |
|
|
if (maybe_clone_body (fn))
|
3076 |
|
|
{
|
3077 |
|
|
/* We don't want to process FN again, so pretend we've written
|
3078 |
|
|
it out, even though we haven't. */
|
3079 |
|
|
TREE_ASM_WRITTEN (fn) = 1;
|
3080 |
|
|
return;
|
3081 |
|
|
}
|
3082 |
|
|
|
3083 |
|
|
/* If this function is marked with the constructor attribute, add it
|
3084 |
|
|
to the list of functions to be called along with constructors
|
3085 |
|
|
from static duration objects. */
|
3086 |
|
|
if (DECL_STATIC_CONSTRUCTOR (fn))
|
3087 |
|
|
static_ctors = tree_cons (NULL_TREE, fn, static_ctors);
|
3088 |
|
|
|
3089 |
|
|
/* If this function is marked with the destructor attribute, add it
|
3090 |
|
|
to the list of functions to be called along with destructors from
|
3091 |
|
|
static duration objects. */
|
3092 |
|
|
if (DECL_STATIC_DESTRUCTOR (fn))
|
3093 |
|
|
static_dtors = tree_cons (NULL_TREE, fn, static_dtors);
|
3094 |
|
|
|
3095 |
|
|
/* We make a decision about linkage for these functions at the end
|
3096 |
|
|
of the compilation. Until that point, we do not want the back
|
3097 |
|
|
end to output them -- but we do want it to see the bodies of
|
3098 |
|
|
these functions so that it can inline them as appropriate. */
|
3099 |
|
|
if (DECL_DECLARED_INLINE_P (fn) || DECL_IMPLICIT_INSTANTIATION (fn))
|
3100 |
|
|
{
|
3101 |
|
|
if (DECL_INTERFACE_KNOWN (fn))
|
3102 |
|
|
/* We've already made a decision as to how this function will
|
3103 |
|
|
be handled. */;
|
3104 |
|
|
else if (!at_eof)
|
3105 |
|
|
{
|
3106 |
|
|
DECL_EXTERNAL (fn) = 1;
|
3107 |
|
|
DECL_NOT_REALLY_EXTERN (fn) = 1;
|
3108 |
|
|
note_vague_linkage_fn (fn);
|
3109 |
|
|
/* A non-template inline function with external linkage will
|
3110 |
|
|
always be COMDAT. As we must eventually determine the
|
3111 |
|
|
linkage of all functions, and as that causes writes to
|
3112 |
|
|
the data mapped in from the PCH file, it's advantageous
|
3113 |
|
|
to mark the functions at this point. */
|
3114 |
|
|
if (!DECL_IMPLICIT_INSTANTIATION (fn))
|
3115 |
|
|
{
|
3116 |
|
|
/* This function must have external linkage, as
|
3117 |
|
|
otherwise DECL_INTERFACE_KNOWN would have been
|
3118 |
|
|
set. */
|
3119 |
|
|
gcc_assert (TREE_PUBLIC (fn));
|
3120 |
|
|
comdat_linkage (fn);
|
3121 |
|
|
DECL_INTERFACE_KNOWN (fn) = 1;
|
3122 |
|
|
}
|
3123 |
|
|
}
|
3124 |
|
|
else
|
3125 |
|
|
import_export_decl (fn);
|
3126 |
|
|
|
3127 |
|
|
/* If the user wants us to keep all inline functions, then mark
|
3128 |
|
|
this function as needed so that finish_file will make sure to
|
3129 |
|
|
output it later. */
|
3130 |
|
|
if (flag_keep_inline_functions && DECL_DECLARED_INLINE_P (fn))
|
3131 |
|
|
mark_needed (fn);
|
3132 |
|
|
}
|
3133 |
|
|
|
3134 |
|
|
/* There's no reason to do any of the work here if we're only doing
|
3135 |
|
|
semantic analysis; this code just generates RTL. */
|
3136 |
|
|
if (flag_syntax_only)
|
3137 |
|
|
return;
|
3138 |
|
|
|
3139 |
|
|
function_depth++;
|
3140 |
|
|
|
3141 |
|
|
/* Expand or defer, at the whim of the compilation unit manager. */
|
3142 |
|
|
cgraph_finalize_function (fn, function_depth > 1);
|
3143 |
|
|
|
3144 |
|
|
function_depth--;
|
3145 |
|
|
}
|
3146 |
|
|
|
3147 |
|
|
struct nrv_data
|
3148 |
|
|
{
|
3149 |
|
|
tree var;
|
3150 |
|
|
tree result;
|
3151 |
|
|
htab_t visited;
|
3152 |
|
|
};
|
3153 |
|
|
|
3154 |
|
|
/* Helper function for walk_tree, used by finalize_nrv below. */
|
3155 |
|
|
|
3156 |
|
|
static tree
|
3157 |
|
|
finalize_nrv_r (tree* tp, int* walk_subtrees, void* data)
|
3158 |
|
|
{
|
3159 |
|
|
struct nrv_data *dp = (struct nrv_data *)data;
|
3160 |
|
|
void **slot;
|
3161 |
|
|
|
3162 |
|
|
/* No need to walk into types. There wouldn't be any need to walk into
|
3163 |
|
|
non-statements, except that we have to consider STMT_EXPRs. */
|
3164 |
|
|
if (TYPE_P (*tp))
|
3165 |
|
|
*walk_subtrees = 0;
|
3166 |
|
|
/* Change all returns to just refer to the RESULT_DECL; this is a nop,
|
3167 |
|
|
but differs from using NULL_TREE in that it indicates that we care
|
3168 |
|
|
about the value of the RESULT_DECL. */
|
3169 |
|
|
else if (TREE_CODE (*tp) == RETURN_EXPR)
|
3170 |
|
|
TREE_OPERAND (*tp, 0) = dp->result;
|
3171 |
|
|
/* Change all cleanups for the NRV to only run when an exception is
|
3172 |
|
|
thrown. */
|
3173 |
|
|
else if (TREE_CODE (*tp) == CLEANUP_STMT
|
3174 |
|
|
&& CLEANUP_DECL (*tp) == dp->var)
|
3175 |
|
|
CLEANUP_EH_ONLY (*tp) = 1;
|
3176 |
|
|
/* Replace the DECL_EXPR for the NRV with an initialization of the
|
3177 |
|
|
RESULT_DECL, if needed. */
|
3178 |
|
|
else if (TREE_CODE (*tp) == DECL_EXPR
|
3179 |
|
|
&& DECL_EXPR_DECL (*tp) == dp->var)
|
3180 |
|
|
{
|
3181 |
|
|
tree init;
|
3182 |
|
|
if (DECL_INITIAL (dp->var)
|
3183 |
|
|
&& DECL_INITIAL (dp->var) != error_mark_node)
|
3184 |
|
|
{
|
3185 |
|
|
init = build2 (INIT_EXPR, void_type_node, dp->result,
|
3186 |
|
|
DECL_INITIAL (dp->var));
|
3187 |
|
|
DECL_INITIAL (dp->var) = error_mark_node;
|
3188 |
|
|
}
|
3189 |
|
|
else
|
3190 |
|
|
init = build_empty_stmt ();
|
3191 |
|
|
SET_EXPR_LOCUS (init, EXPR_LOCUS (*tp));
|
3192 |
|
|
*tp = init;
|
3193 |
|
|
}
|
3194 |
|
|
/* And replace all uses of the NRV with the RESULT_DECL. */
|
3195 |
|
|
else if (*tp == dp->var)
|
3196 |
|
|
*tp = dp->result;
|
3197 |
|
|
|
3198 |
|
|
/* Avoid walking into the same tree more than once. Unfortunately, we
|
3199 |
|
|
can't just use walk_tree_without duplicates because it would only call
|
3200 |
|
|
us for the first occurrence of dp->var in the function body. */
|
3201 |
|
|
slot = htab_find_slot (dp->visited, *tp, INSERT);
|
3202 |
|
|
if (*slot)
|
3203 |
|
|
*walk_subtrees = 0;
|
3204 |
|
|
else
|
3205 |
|
|
*slot = *tp;
|
3206 |
|
|
|
3207 |
|
|
/* Keep iterating. */
|
3208 |
|
|
return NULL_TREE;
|
3209 |
|
|
}
|
3210 |
|
|
|
3211 |
|
|
/* Called from finish_function to implement the named return value
|
3212 |
|
|
optimization by overriding all the RETURN_EXPRs and pertinent
|
3213 |
|
|
CLEANUP_STMTs and replacing all occurrences of VAR with RESULT, the
|
3214 |
|
|
RESULT_DECL for the function. */
|
3215 |
|
|
|
3216 |
|
|
void
|
3217 |
|
|
finalize_nrv (tree *tp, tree var, tree result)
|
3218 |
|
|
{
|
3219 |
|
|
struct nrv_data data;
|
3220 |
|
|
|
3221 |
|
|
/* Copy debugging information from VAR to RESULT. */
|
3222 |
|
|
DECL_NAME (result) = DECL_NAME (var);
|
3223 |
|
|
DECL_ARTIFICIAL (result) = DECL_ARTIFICIAL (var);
|
3224 |
|
|
DECL_IGNORED_P (result) = DECL_IGNORED_P (var);
|
3225 |
|
|
DECL_SOURCE_LOCATION (result) = DECL_SOURCE_LOCATION (var);
|
3226 |
|
|
DECL_ABSTRACT_ORIGIN (result) = DECL_ABSTRACT_ORIGIN (var);
|
3227 |
|
|
/* Don't forget that we take its address. */
|
3228 |
|
|
TREE_ADDRESSABLE (result) = TREE_ADDRESSABLE (var);
|
3229 |
|
|
|
3230 |
|
|
data.var = var;
|
3231 |
|
|
data.result = result;
|
3232 |
|
|
data.visited = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
|
3233 |
|
|
walk_tree (tp, finalize_nrv_r, &data, 0);
|
3234 |
|
|
htab_delete (data.visited);
|
3235 |
|
|
}
|
3236 |
|
|
|
3237 |
|
|
/* Perform initialization related to this module. */
|
3238 |
|
|
|
3239 |
|
|
void
|
3240 |
|
|
init_cp_semantics (void)
|
3241 |
|
|
{
|
3242 |
|
|
}
|
3243 |
|
|
|
3244 |
|
|
#include "gt-cp-semantics.h"
|