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